merge source and target bindings into single field

Author: LorrensP-2158466

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -7,6 +7,7 @@
 
 use std::cell::Cell;
 use std::sync::Arc;
+use std::task::Poll;
 
 use rustc_ast::visit::{self, AssocCtxt, Visitor, WalkItemKind};
 use rustc_ast::{
@@ -32,10 +33,9 @@ use crate::def_collector::collect_definitions;
 use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
-    BindingKey, Determinacy, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind,
-    ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
-    ResolutionError, Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError,
-    errors,
+    BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
+    NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult, ResolutionError,
+    Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -618,19 +618,24 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 let kind = ImportKind::Single {
                     source: source.ident,
                     target: ident,
-                    source_bindings: PerNS {
-                        type_ns: Cell::new(Err(Determinacy::Undetermined)),
-                        value_ns: Cell::new(Err(Determinacy::Undetermined)),
-                        macro_ns: Cell::new(Err(Determinacy::Undetermined)),
-                    },
-                    target_bindings: PerNS {
-                        type_ns: Cell::new(None),
-                        value_ns: Cell::new(None),
-                        macro_ns: Cell::new(None),
-                    },
+                    // source_bindings: PerNS {
+                    //     type_ns: Cell::new(Err(Determinacy::Undetermined)),
+                    //     value_ns: Cell::new(Err(Determinacy::Undetermined)),
+                    //     macro_ns: Cell::new(Err(Determinacy::Undetermined)),
+                    // },
+                    // target_bindings: PerNS {
+                    //     type_ns: Cell::new(None),
+                    //     value_ns: Cell::new(None),
+                    //     macro_ns: Cell::new(None),
+                    // },
                     type_ns_only,
                     nested,
                     id,
+                    bindings: PerNS {
+                        value_ns: Cell::new(Poll::Pending),
+                        type_ns: Cell::new(Poll::Pending),
+                        macro_ns: Cell::new(Poll::Pending),
+                    },
                 };
 
                 self.add_import(module_path, kind, use_tree.span, item, root_span, item.id, vis);

compiler/rustc_resolve/src/ident.rs

@@ -977,19 +977,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let Some(module) = single_import.imported_module.get() else {
                 return Err((Undetermined, Weak::No));
             };
-            let ImportKind::Single { source, target, target_bindings, .. } = &single_import.kind
-            else {
+            let ImportKind::Single { source, target, bindings, .. } = &single_import.kind else {
                 unreachable!();
             };
             if source != target {
                 // This branch allows the binding to be defined or updated later if the target name
                 // can hide the source.
-                if target_bindings.iter().all(|binding| binding.get().is_none()) {
+                if bindings.iter().all(|binding| binding.get().is_pending()) {
                     // None of the target bindings are available, so we can't determine
                     // if this binding is correct or not.
                     // See more details in #124840
                     return Err((Undetermined, Weak::No));
-                } else if target_bindings[ns].get().is_none() && binding.is_some() {
+                } else if bindings[ns].get().is_pending() && binding.is_some() {
                     // `binding.is_some()` avoids the condition where the binding
                     // truly doesn't exist in this namespace and should return `Err(Determined)`.
                     return Err((Undetermined, Weak::No));