Try to sort bindings before usage to have a stable result

The `FxIndexMap` solution seems costly.

Author: ismailarilik

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: FxIndexMap<Ident, R>,
+    pub bindings: FxHashMap<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
-                            .shift_remove(&Ident::with_dummy_span(param.ident.name));
+                            .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
-                            .shift_remove(&Ident::with_dummy_span(param.ident.name));
+                            .remove(&Ident::with_dummy_span(param.ident.name));
                     }
                 }
             }
@@ -2795,8 +2795,12 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         break;
                     }
 
-                    seen_bindings
-                        .extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span)));
+                    // 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)));
                 }
             }
 
@@ -3868,7 +3872,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         }
     }
 
-    fn innermost_rib_bindings(&mut self, ns: Namespace) -> &mut FxIndexMap<Ident, Res> {
+    fn innermost_rib_bindings(&mut self, ns: Namespace) -> &mut FxHashMap<Ident, Res> {
         &mut self.ribs[ns].last_mut().unwrap().bindings
     }
 

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -762,7 +762,12 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         if let Some(rib) = &self.last_block_rib
             && let RibKind::Normal = rib.kind
         {
-            for (ident, &res) in &rib.bindings {
+            // 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 {
                 if let Res::Local(_) = res
                     && path.len() == 1
                     && ident.span.eq_ctxt(path[0].ident.span)
@@ -944,7 +949,12 @@ 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 {
-                    for (label_ident, node_id) in &label_rib.bindings {
+                    // 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 {
                         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");
@@ -2142,6 +2152,8 @@ 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));
@@ -2605,18 +2617,28 @@ 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];
-        let names = rib
+        // `names` is sorted below so ordering is not important here.
+        #[allow(rustc::potential_query_instability)]
+        let mut 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, _) = rib.bindings.iter().find(|(ident, _)| ident.name == symbol).unwrap();
+            let (ident, _) = bindings.iter().find(|(ident, _)| ident.name == symbol).unwrap();
             (*ident, within_scope)
         })
     }