address review

Author: LorrensP-2158466

compiler/rustc_resolve/src/imports.rs

@@ -25,7 +25,6 @@ use rustc_span::{Ident, Span, Symbol, kw, sym};
 use smallvec::SmallVec;
 use tracing::debug;
 
-use crate::Determinacy::{self};
 use crate::Namespace::*;
 use crate::diagnostics::{DiagMode, Suggestion, import_candidates};
 use crate::errors::{
@@ -34,7 +33,7 @@ use crate::errors::{
     ConsiderAddingMacroExport, ConsiderMarkingAsPub,
 };
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingKey, Finalize, ImportSuggestion, Module,
+    AmbiguityError, AmbiguityKind, BindingKey, Determinacy, Finalize, ImportSuggestion, Module,
     ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
     PerNS, ResolutionError, Resolver, ScopeSet, Segment, Used, module_to_string, names_to_string,
 };
@@ -568,7 +567,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             if let ImportKind::Single { source, ref bindings, .. } = import.kind
                 && source.name == kw::SelfLower
                 // Silence `unresolved import` error if E0429 is already emitted
-                // `indings` here is "target_bindings", if it is "Err(Determined)" then `source_bindings` as well.
                 && let Progress::Ready(None) = bindings.value_ns.get()
             {
                 continue;
@@ -832,29 +830,22 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut indeterminate_count = 0;
         self.per_ns(|this, ns| {
             if !type_ns_only || ns == TypeNS {
-                if let Progress::Pending = bindings[ns].get() {
-                    let binding_result = this.maybe_resolve_ident_in_module(
-                        module,
-                        source,
-                        ns,
-                        &import.parent_scope,
-                        Some(import),
-                    );
-                    let binding = match binding_result {
-                        // We need the `target`, `source` can be extracted.
-                        Ok(binding) => Poll::Ready(Some(this.import(binding, import))),
-                        Err(Determinacy::Determined) => Poll::Ready(None),
-                        Err(Determinacy::Undetermined) => Poll::Pending,
-                    };
-                    bindings[ns].set(binding);
-                } else {
+                let Progress::Pending = bindings[ns].get() else {
                     return;
                 };
-
+                let binding_result = this.maybe_resolve_ident_in_module(
+                    module,
+                    source,
+                    ns,
+                    &import.parent_scope,
+                    Some(import),
+                );
                 let parent = import.parent_scope.module;
-                match bindings[ns].get() {
-                    Progress::Ready(Some(binding)) => {
-                        if binding.is_assoc_item()
+                let binding = match binding_result {
+                    Ok(binding) => {
+                        // We need the `target`, `source` can be extracted.
+                        let imported_binding = this.import(binding, import);
+                        if imported_binding.is_assoc_item()
                             && !this.tcx.features().import_trait_associated_functions()
                         {
                             feature_err(
@@ -865,19 +856,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             )
                             .emit();
                         }
-                        this.define(parent, target, ns, binding);
+                        this.define(parent, target, ns, imported_binding);
+                        Poll::Ready(Some(imported_binding))
                     }
-                    Progress::Ready(None) => {
+                    Err(Determinacy::Determined) => {
                         // Don't update the resolution for underscores, because it was never added.
                         if target.name != kw::Underscore {
                             let key = BindingKey::new(target, ns);
                             this.update_resolution(parent, key, false, |_, resolution| {
                                 resolution.single_imports.swap_remove(&import);
                             });
                         }
+                        Poll::Ready(None)
                     }
-                    Progress::Pending => indeterminate_count += 1,
-                }
+                    Err(Determinacy::Undetermined) => {
+                        indeterminate_count += 1;
+                        Poll::Pending
+                    }
+                };
+                bindings[ns].set(binding);
             }
         });
 
@@ -1101,7 +1098,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     Ok(binding) => {
                         // Consistency checks, analogous to `finalize_macro_resolutions`.
                         let initial_res = bindings[ns].get().map(|maybe_binding| {
-                            maybe_binding.and_then(|binding| binding.maybe_source_binding()).map(
+                            maybe_binding.map(|binding| binding.import_source()).map(
                                 |initial_binding| {
                                     all_ns_err = false;
                                     if let Progress::Ready(Some(binding)) = bindings[ns].get()
@@ -1272,7 +1269,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut crate_private_reexport = false;
         self.per_ns(|this, ns| {
             let binding = match bindings[ns].get() {
-                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                Poll::Ready(Some(binding)) => Some(binding.import_source()),
                 _ => None,
             };
             let Some(binding) = binding else {
@@ -1346,7 +1343,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let mut full_path = import.module_path.clone();
             full_path.push(Segment::from_ident(ident));
             self.per_ns(|this, ns| {
-                if let Progress::Ready(Some(binding)) = bindings[ns].get() {
+                let binding = match bindings[ns].get() {
+                    Poll::Ready(Some(binding)) => Some(binding.import_source()),
+                    _ => None,
+                };
+                if let Some(binding) = binding {
                     this.lint_if_path_starts_with_module(Some(finalize), &full_path, Some(binding));
                 }
             });
@@ -1357,7 +1358,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // purposes it's good enough to just favor one over the other.
         self.per_ns(|this, ns| {
             let binding = match bindings[ns].get() {
-                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                Poll::Ready(Some(binding)) => Some(binding.import_source()),
                 _ => None,
             };
             if let Some(binding) = binding {
@@ -1399,7 +1400,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
         self.per_ns(|this, ns| {
             let binding = match bindings[ns].get() {
-                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                Poll::Ready(Some(binding)) => Some(binding.import_source()),
                 _ => None,
             };
             if is_redundant && let Some(binding) = binding {

compiler/rustc_resolve/src/lib.rs

@@ -891,10 +891,10 @@ impl<'ra> NameBindingData<'ra> {
         }
     }
 
-    fn maybe_source_binding(&self) -> Option<NameBinding<'ra>> {
+    fn import_source(&self) -> NameBinding<'ra> {
         match self.kind {
-            NameBindingKind::Import { binding, .. } => Some(binding),
-            _ => None,
+            NameBindingKind::Import { binding, .. } => binding,
+            _ => unreachable!(),
         }
     }