fix duplicate errors

Author: LorrensP-2158466

compiler/rustc_resolve/src/imports.rs

@@ -53,7 +53,7 @@ enum SideEffectBindings<'ra> {
         import_bindings: PerNS<Option<Option<NameBinding<'ra>>>>,
     },
     Glob {
-        import_bindings: Vec<(NameBinding<'ra>, BindingKey, bool /* warn_ambiguity */)>,
+        import_bindings: Vec<(NameBinding<'ra>, BindingKey)>,
     },
 }
 
@@ -601,9 +601,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         &mut self,
         import_resolutions: Vec<(Import<'ra>, SideEffect<'ra>)>,
     ) {
-        self.determined_imports.reserve(self.determined_imports.len());
         for (import, side_effect) in import_resolutions.iter() {
-            self.determined_imports.push(*import);
             let SideEffect { imported_module, .. } = side_effect;
             import.imported_module.set(Some(*imported_module));
 
@@ -679,12 +677,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         .emit();
                     }
 
-                    for (binding, key, warn_ambiguity) in import_bindings {
+                    for (binding, key) in import_bindings {
+                        let imported_binding = self.import(binding, import);
+                        let warn_ambiguity = self
+                            .resolution(import.parent_scope.module, key)
+                            .and_then(|r| r.binding())
+                            .is_some_and(|binding| binding.warn_ambiguity_recursive());
                         let _ = self.try_define_local(
                             parent,
                             key.ident.0,
                             key.ns,
-                            binding,
+                            imported_binding,
                             warn_ambiguity,
                         );
                     }
@@ -1592,47 +1595,40 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         false
     }
 
-    fn resolve_glob_import<'r>(
-        self: &mut CmResolver<'r, 'ra, 'tcx>,
+    fn resolve_glob_import(
+        &self,
         import: Import<'ra>,
         imported_module: ModuleOrUniformRoot<'ra>,
     ) -> SideEffectBindings<'ra> {
-        // This function is only called for glob imports.
-        let ImportKind::Glob { .. } = import.kind else { unreachable!() };
+        match imported_module {
+            ModuleOrUniformRoot::Module(module) if module != import.parent_scope.module => {
+                let import_bindings = self
+                    .resolutions(module)
+                    .borrow()
+                    .iter()
+                    .filter_map(|(key, resolution)| {
+                        let binding = resolution.borrow().binding()?;
+                        let mut key = *key;
+                        let scope = match key
+                            .ident
+                            .0
+                            .span
+                            .reverse_glob_adjust(module.expansion, import.span)
+                        {
+                            Some(Some(def)) => self.expn_def_scope(def),
+                            Some(None) => import.parent_scope.module,
+                            None => return None,
+                        };
+                        self.is_accessible_from(binding.vis, scope).then(|| (binding, key))
+                    })
+                    .collect::<Vec<_>>();
 
-        let ModuleOrUniformRoot::Module(module) = imported_module else {
-            return SideEffectBindings::None;
-        };
+                SideEffectBindings::Glob { import_bindings }
+            }
 
-        if module == import.parent_scope.module {
-            return SideEffectBindings::None;
+            // Errors are reported in `commit_imports_resolutions`
+            _ => SideEffectBindings::None,
         }
-
-        let import_bindings = self
-            .resolutions(module)
-            .borrow()
-            .iter()
-            .filter_map(|(key, resolution)| {
-                let binding = resolution.borrow().binding()?;
-                let mut key = *key;
-                let scope =
-                    match key.ident.0.span.reverse_glob_adjust(module.expansion, import.span) {
-                        Some(Some(def)) => self.expn_def_scope(def),
-                        Some(None) => import.parent_scope.module,
-                        None => return None,
-                    };
-                self.is_accessible_from(binding.vis, scope).then(|| {
-                    let imported_binding = self.import(binding, import);
-                    let warn_ambiguity = self
-                        .resolution(import.parent_scope.module, key)
-                        .and_then(|r| r.binding())
-                        .is_some_and(|binding| binding.warn_ambiguity_recursive());
-                    (imported_binding, key, warn_ambiguity)
-                })
-            })
-            .collect::<Vec<_>>();
-
-        SideEffectBindings::Glob { import_bindings }
     }
 
     // Miscellaneous post-processing, including recording re-exports,