Use swap_remove instead of shift_remove

`shift_remove` is very expensive

Author: ismailarilik

compiler/rustc_resolve/src/ident.rs

@@ -984,14 +984,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         // --- From now on we either have a glob resolution or no resolution. ---
 
-        // It is sorted before usage so ordering is not important.
-        #[allow(rustc::potential_query_instability)]
-        let mut single_imports: Vec<_> = resolution.single_imports.clone().into_iter().collect();
-        single_imports.sort_by_key(|import| import.0.id());
-
         // Check if one of single imports can still define the name,
         // if it can then our result is not determined and can be invalidated.
-        for single_import in &single_imports {
+        for single_import in &resolution.single_imports {
             if ignore_import == Some(*single_import) {
                 // This branch handles a cycle in single imports.
                 //

compiler/rustc_resolve/src/imports.rs

@@ -4,7 +4,7 @@ use std::cell::Cell;
 use std::mem;
 
 use rustc_ast::NodeId;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
@@ -220,7 +220,7 @@ impl<'ra> ImportData<'ra> {
 pub(crate) struct NameResolution<'ra> {
     /// Single imports that may define the name in the namespace.
     /// Imports are arena-allocated, so it's ok to use pointers as keys.
-    pub single_imports: FxHashSet<Import<'ra>>,
+    pub single_imports: FxIndexSet<Import<'ra>>,
     /// The least shadowable known binding for this name, or None if there are no known bindings.
     pub binding: Option<NameBinding<'ra>>,
     pub shadowed_glob: Option<NameBinding<'ra>>,
@@ -482,7 +482,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 let key = BindingKey::new(target, ns);
                 let _ = this.try_define(import.parent_scope.module, key, dummy_binding, false);
                 this.update_resolution(import.parent_scope.module, key, false, |_, resolution| {
-                    resolution.single_imports.remove(&import);
+                    resolution.single_imports.swap_remove(&import);
                 })
             });
             self.record_use(target, dummy_binding, Used::Other);
@@ -837,7 +837,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         }
                         let key = BindingKey::new(target, ns);
                         this.update_resolution(parent, key, false, |_, resolution| {
-                            resolution.single_imports.remove(&import);
+                            resolution.single_imports.swap_remove(&import);
                         });
                     }
                 }

compiler/rustc_resolve/src/late.rs

@@ -259,7 +259,7 @@ impl RibKind<'_> {
 /// resolving, the name is looked up from inside out.
 #[derive(Debug)]
 pub(crate) struct Rib<'ra, R = Res> {
-    pub bindings: FxHashMap<Ident, R>,
+    pub bindings: FxIndexMap<Ident, R>,
     pub kind: RibKind<'ra>,
 }
 
@@ -1548,7 +1548,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         // Allow all following defaults to refer to this type parameter.
                         forward_ty_ban_rib
                             .bindings
-                            .remove(&Ident::with_dummy_span(param.ident.name));
+                            .swap_remove(&Ident::with_dummy_span(param.ident.name));
                     }
                     GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
                         // Const parameters can't have param bounds.
@@ -1576,7 +1576,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         // Allow all following defaults to refer to this const parameter.
                         forward_const_ban_rib
                             .bindings
-                            .remove(&Ident::with_dummy_span(param.ident.name));
+                            .swap_remove(&Ident::with_dummy_span(param.ident.name));
                     }
                 }
             }
@@ -2795,12 +2795,8 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         break;
                     }
 
-                    // It is sorted before usage so ordering is not important here.
-                    #[allow(rustc::potential_query_instability)]
-                    let mut idents: Vec<_> = parent_rib.bindings.keys().into_iter().collect();
-                    idents.sort_by_key(|&ident| ident.span);
-
-                    seen_bindings.extend(idents.into_iter().map(|ident| (*ident, ident.span)));
+                    seen_bindings
+                        .extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span)));
                 }
             }
 
@@ -3872,7 +3868,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         }
     }
 
-    fn innermost_rib_bindings(&mut self, ns: Namespace) -> &mut FxHashMap<Ident, Res> {
+    fn innermost_rib_bindings(&mut self, ns: Namespace) -> &mut FxIndexMap<Ident, Res> {
         &mut self.ribs[ns].last_mut().unwrap().bindings
     }
 

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -762,12 +762,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         if let Some(rib) = &self.last_block_rib
             && let RibKind::Normal = rib.kind
         {
-            // It is sorted before usage so ordering is not important here.
-            #[allow(rustc::potential_query_instability)]
-            let mut bindings: Vec<_> = rib.bindings.clone().into_iter().collect();
-            bindings.sort_by_key(|(ident, _)| ident.span);
-
-            for (ident, res) in &bindings {
+            for (ident, &res) in &rib.bindings {
                 if let Res::Local(_) = res
                     && path.len() == 1
                     && ident.span.eq_ctxt(path[0].ident.span)
@@ -949,12 +944,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         if let Some(err_code) = err.code {
             if err_code == E0425 {
                 for label_rib in &self.label_ribs {
-                    // It is sorted before usage so ordering is not important here.
-                    #[allow(rustc::potential_query_instability)]
-                    let mut bindings: Vec<_> = label_rib.bindings.clone().into_iter().collect();
-                    bindings.sort_by_key(|(ident, _)| ident.span);
-
-                    for (label_ident, node_id) in &bindings {
+                    for (label_ident, node_id) in &label_rib.bindings {
                         let ident = path.last().unwrap().ident;
                         if format!("'{ident}") == label_ident.to_string() {
                             err.span_label(label_ident.span, "a label with a similar name exists");
@@ -2152,8 +2142,6 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 };
 
                 // Locals and type parameters
-                // `names` is sorted below so ordering is not important here.
-                #[allow(rustc::potential_query_instability)]
                 for (ident, &res) in &rib.bindings {
                     if filter_fn(res) && ident.span.ctxt() == rib_ctxt {
                         names.push(TypoSuggestion::typo_from_ident(*ident, res));
@@ -2617,28 +2605,18 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         let within_scope = self.is_label_valid_from_rib(rib_index);
 
         let rib = &self.label_ribs[rib_index];
-        // `names` is sorted below so ordering is not important here.
-        #[allow(rustc::potential_query_instability)]
-        let mut names = rib
+        let names = rib
             .bindings
             .iter()
             .filter(|(id, _)| id.span.eq_ctxt(label.span))
             .map(|(id, _)| id.name)
             .collect::<Vec<Symbol>>();
 
-        // Make sure error reporting is deterministic.
-        names.sort();
-
         find_best_match_for_name(&names, label.name, None).map(|symbol| {
-            // It is sorted before usage so ordering is not important here.
-            #[allow(rustc::potential_query_instability)]
-            let mut bindings: Vec<_> = rib.bindings.clone().into_iter().collect();
-            bindings.sort_by_key(|(ident, _)| ident.span);
-
             // Upon finding a similar name, get the ident that it was from - the span
             // contained within helps make a useful diagnostic. In addition, determine
             // whether this candidate is within scope.
-            let (ident, _) = bindings.iter().find(|(ident, _)| ident.name == symbol).unwrap();
+            let (ident, _) = rib.bindings.iter().find(|(ident, _)| ident.name == symbol).unwrap();
             (*ident, within_scope)
         })
     }