extract source_binding out of bindings

Author: LorrensP-2158466

compiler/rustc_resolve/src/imports.rs

@@ -571,6 +571,7 @@ 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;
@@ -835,15 +836,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         self.per_ns(|this, ns| {
             if !type_ns_only || ns == TypeNS {
                 if let Progress::Pending = bindings[ns].get() {
-                    let binding = this.maybe_resolve_ident_in_module(
+                    let binding_result = this.maybe_resolve_ident_in_module(
                         module,
                         source,
                         ns,
                         &import.parent_scope,
                         Some(import),
                     );
-                    let binding = match binding {
-                        Ok(binding) => Poll::Ready(Some(binding)),
+                    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,
                     };
@@ -866,10 +868,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             )
                             .emit();
                         }
-
-                        let imported_binding = this.import(binding, import);
-                        // target_bindings[ns].set(Some(imported_binding));
-                        this.define(parent, target, ns, imported_binding);
+                        this.define(parent, target, ns, binding);
                     }
                     Progress::Ready(None) => {
                         // Don't update the resolution for underscores, because it was never added.
@@ -1104,21 +1103,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 match binding {
                     Ok(binding) => {
                         // Consistency checks, analogous to `finalize_macro_resolutions`.
-                        let initial_res = bindings[ns].get().map(|initial_binding| {
-                            all_ns_err = false;
-                            if let Some(binding) = initial_binding
-                                && target.name == kw::Underscore
-                                && binding.is_extern_crate()
-                                && !binding.is_import()
-                            {
-                                let used = if import.module_path.is_empty() {
-                                    Used::Scope
-                                } else {
-                                    Used::Other
-                                };
-                                this.record_use(ident, binding, used);
-                            }
-                            binding.res()
+                        let initial_res = bindings[ns].get().map(|maybe_binding| {
+                            maybe_binding.and_then(|binding| binding.maybe_source_binding()).map(
+                                |initial_binding| {
+                                    all_ns_err = false;
+                                    if let Progress::Ready(Some(binding)) = bindings[ns].get()
+                                        && target.name == kw::Underscore
+                                        && initial_binding.is_extern_crate()
+                                        && !initial_binding.is_import()
+                                    {
+                                        let used = if import.module_path.is_empty() {
+                                            Used::Scope
+                                        } else {
+                                            Used::Other
+                                        };
+                                        this.record_use(ident, binding, used);
+                                    }
+                                    binding.res()
+                                },
+                            )
                         });
                         let res = binding.res();
                         let has_ambiguity_error =
@@ -1128,7 +1131,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 .span_delayed_bug(import.span, "some error happened for an import");
                             return;
                         }
-                        if let Progress::Ready(initial_res) = initial_res {
+                        if let Progress::Ready(Some(initial_res)) = initial_res {
                             if res != initial_res {
                                 span_bug!(import.span, "inconsistent resolution for an import");
                             }
@@ -1271,7 +1274,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut any_successful_reexport = false;
         let mut crate_private_reexport = false;
         self.per_ns(|this, ns| {
-            let Progress::Ready(Some(binding)) = bindings[ns].get() else {
+            let binding = match bindings[ns].get() {
+                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                _ => None,
+            };
+            let Some(binding) = binding else {
                 return;
             };
 
@@ -1352,7 +1359,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // this may resolve to either a value or a type, but for documentation
         // purposes it's good enough to just favor one over the other.
         self.per_ns(|this, ns| {
-            if let Progress::Ready(Some(binding)) = bindings[ns].get() {
+            let binding = match bindings[ns].get() {
+                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                _ => None,
+            };
+            if let Some(binding) = binding {
                 this.import_res_map.entry(import_id).or_default()[ns] = Some(binding.res());
             }
         });
@@ -1390,7 +1401,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut is_redundant = true;
         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
         self.per_ns(|this, ns| {
-            if is_redundant && let Poll::Ready(Some(binding)) = bindings[ns].get() {
+            let binding = match bindings[ns].get() {
+                Poll::Ready(Some(binding)) => binding.maybe_source_binding(),
+                _ => None,
+            };
+            if is_redundant && let Some(binding) = binding {
                 if binding.res() == Res::Err {
                     return;
                 }

compiler/rustc_resolve/src/lib.rs

@@ -891,6 +891,13 @@ impl<'ra> NameBindingData<'ra> {
         }
     }
 
+    fn maybe_source_binding(&self) -> Option<NameBinding<'ra>> {
+        match self.kind {
+            NameBindingKind::Import { binding, .. } => Some(binding),
+            _ => None,
+        }
+    }
+
     fn is_ambiguity_recursive(&self) -> bool {
         self.ambiguity.is_some()
             || match self.kind {