correct assignment of bindings and remove PerNs::into_iter_(with)

Author: LorrensP-2158466

compiler/rustc_hir/src/def.rs

@@ -708,24 +708,6 @@ impl<T> PerNS<T> {
     pub fn iter(&self) -> IntoIter<&T, 3> {
         [&self.value_ns, &self.type_ns, &self.macro_ns].into_iter()
     }
-
-    pub fn into_iter_with(self) -> IntoIter<(Namespace, T), 3> {
-        [
-            (Namespace::TypeNS, self.type_ns),
-            (Namespace::ValueNS, self.value_ns),
-            (Namespace::MacroNS, self.macro_ns),
-        ]
-        .into_iter()
-    }
-
-    pub fn iter_with(&self) -> IntoIter<(Namespace, &T), 3> {
-        [
-            (Namespace::TypeNS, &self.type_ns),
-            (Namespace::ValueNS, &self.value_ns),
-            (Namespace::MacroNS, &self.macro_ns),
-        ]
-        .into_iter()
-    }
 }
 
 impl<T> ::std::ops::Index<Namespace> for PerNS<T> {

compiler/rustc_resolve/src/imports.rs

@@ -82,32 +82,40 @@ impl<'ra> ImportResolutionOutputs<'ra> {
                     ImportKind::Single { target, bindings, .. },
                     SideEffectBindings::Single { import_bindings },
                 ) => {
-                    for (ns, pending_binding) in import_bindings.into_iter_with() {
-                        match pending_binding {
+                    r.per_ns(|this, ns| {
+                        match import_bindings[ns] {
                             PendingBinding::Ready(Some(binding)) => {
                                 if binding.is_assoc_item()
-                                    && !r.tcx.features().import_trait_associated_functions()
+                                    && !this.tcx.features().import_trait_associated_functions()
                                 {
                                     feature_err(
-                                        r.tcx.sess,
+                                        this.tcx.sess,
                                         sym::import_trait_associated_functions,
                                         import.span,
                                         "`use` associated items of traits is unstable",
                                     )
                                     .emit();
                                 }
-                                r.define_binding_local(parent, *target, ns, binding);
+                                this.define_binding_local(parent, *target, ns, binding);
                             }
                             PendingBinding::Ready(None) => {
-                                let key = BindingKey::new(*target, ns);
-                                r.update_local_resolution(parent, key, false, |_, resolution| {
-                                    resolution.single_imports.swap_remove(&import);
-                                });
+                                // Don't remove underscores from `single_imports`, they were never added.
+                                if target.name != kw::Underscore {
+                                    let key = BindingKey::new(*target, ns);
+                                    this.update_local_resolution(
+                                        parent,
+                                        key,
+                                        false,
+                                        |_, resolution| {
+                                            resolution.single_imports.swap_remove(&import);
+                                        },
+                                    );
+                                }
                             }
                             _ => {}
                         }
-                        bindings[ns].set(pending_binding);
-                    }
+                        bindings[ns].set(import_bindings[ns]);
+                    });
                 }
                 (ImportKind::Glob { id, .. }, SideEffectBindings::Glob { import_bindings }) => {
                     let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap()
@@ -973,7 +981,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         };
 
-        let (source, target, bindings, type_ns_only) = match import.kind {
+        let (source, _, bindings, type_ns_only) = match import.kind {
             ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
                 (source, target, bindings, type_ns_only)
             }
@@ -989,7 +997,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             _ => unreachable!(),
         };
 
-        let mut import_bindings = PerNS::default();
+        let mut import_bindings = bindings.clone().map(|b| b.get());
         let mut indeterminate_count = 0;
         self.reborrow().per_ns_cm(|this, ns| {
             if !type_ns_only || ns == TypeNS {
@@ -1009,16 +1017,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         let imported_binding = this.import(binding, import);
                         PendingBinding::Ready(Some(imported_binding))
                     }
-                    Err(Determinacy::Determined) => {
-                        // Don't remove underscores from `single_imports`, they were never added.
-                        if target.name == kw::Underscore {
-                            return;
-                        }
-                        PendingBinding::Ready(None)
-                    }
+                    Err(Determinacy::Determined) => PendingBinding::Ready(None),
                     Err(Determinacy::Undetermined) => {
                         indeterminate_count += 1;
-                        return;
+                        PendingBinding::Pending
                     }
                 };
                 import_bindings[ns] = pending_binding;