Handle rustc_query_system cases of rustc::potential_query_instability lint

compiler/rustc_data_structures/src/fx.rs

@@ -1,5 +1,6 @@
 use std::hash::BuildHasherDefault;
 
+pub use indexmap::map::RawEntryApiV1 as IndexRawEntryApiV1;
 pub use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 
 pub type StdEntry<'a, K, V> = std::collections::hash_map::Entry<'a, K, V>;

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -1389,6 +1389,8 @@ fn panic_on_forbidden_read<D: Deps>(data: &DepGraphData<D>, dep_node_index: DepN
     if dep_node.is_none() {
         // Try to find it among the new nodes
         for shard in data.current.new_node_to_index.lock_shards() {
+            // This is OK, as there can be at most one `dep_node` with the given `dep_node_index`
+            #[allow(rustc::potential_query_instability)]
             if let Some((node, _)) = shard.iter().find(|(_, index)| **index == dep_node_index) {
                 dep_node = Some(*node);
                 break;

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -651,6 +651,8 @@ impl<D: Deps> GraphEncoder<D> {
         let mut status = self.status.lock();
         let status = status.as_mut().unwrap();
         if let Some(record_stats) = &status.stats {
+            // `stats` is sorted below so we can allow this lint here.
+            #[allow(rustc::potential_query_instability)]
             let mut stats: Vec<_> = record_stats.values().collect();
             stats.sort_by_key(|s| -(s.node_counter as i64));
 

compiler/rustc_query_system/src/lib.rs

@@ -1,5 +1,5 @@
 // tidy-alphabetical-start
-#![allow(rustc::potential_query_instability, internal_features)]
+#![allow(internal_features)]
 #![feature(assert_matches)]
 #![feature(core_intrinsics)]
 #![feature(hash_raw_entry)]

compiler/rustc_query_system/src/query/caches.rs

@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxIndexMap, IndexRawEntryApiV1};
 use rustc_data_structures::sharded::{self, Sharded};
 use rustc_data_structures::sync::{Lock, OnceLock};
 use rustc_hir::def_id::LOCAL_CRATE;
@@ -23,7 +23,7 @@ pub trait QueryCache: Sized {
 }
 
 pub struct DefaultCache<K, V> {
-    cache: Sharded<FxHashMap<K, (V, DepNodeIndex)>>,
+    cache: Sharded<FxIndexMap<K, (V, DepNodeIndex)>>,
 }
 
 impl<K, V> Default for DefaultCache<K, V> {
@@ -44,7 +44,7 @@ where
     fn lookup(&self, key: &K) -> Option<(V, DepNodeIndex)> {
         let key_hash = sharded::make_hash(key);
         let lock = self.cache.lock_shard_by_hash(key_hash);
-        let result = lock.raw_entry().from_key_hashed_nocheck(key_hash, key);
+        let result = lock.raw_entry_v1().from_key_hashed_nocheck(key_hash, key);
 
         if let Some((_, value)) = result { Some(*value) } else { None }
     }

compiler/rustc_query_system/src/query/job.rs

@@ -2,7 +2,7 @@ use std::hash::Hash;
 use std::io::Write;
 use std::num::NonZero;
 
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
 use rustc_session::Session;
@@ -30,7 +30,7 @@ pub struct QueryInfo {
     pub query: QueryStackFrame,
 }
 
-pub type QueryMap = FxHashMap<QueryJobId, QueryJobInfo>;
+pub type QueryMap = FxIndexMap<QueryJobId, QueryJobInfo>;
 
 /// A value uniquely identifying an active query job.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]

compiler/rustc_query_system/src/query/plumbing.rs

@@ -3,13 +3,12 @@
 //! manage the caches, and so forth.
 
 use std::cell::Cell;
-use std::collections::hash_map::Entry;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::mem;
 
 use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxIndexMap, IndexEntry};
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::Lock;
@@ -33,7 +32,7 @@ use crate::query::{
 };
 
 pub struct QueryState<K> {
-    active: Sharded<FxHashMap<K, QueryResult>>,
+    active: Sharded<FxIndexMap<K, QueryResult>>,
 }
 
 /// Indicates the state of a query for a given key in a query map.
@@ -187,7 +186,7 @@ where
                 // since unwinding also wants to look at this map, this can also prevent a double
                 // panic.
                 let mut lock = state.active.lock_shard_by_value(&key);
-                lock.remove(&key)
+                lock.shift_remove(&key)
             };
             val.unwrap().expect_job()
         };
@@ -207,7 +206,7 @@ where
         let state = self.state;
         let job = {
             let mut shard = state.active.lock_shard_by_value(&self.key);
-            let job = shard.remove(&self.key).unwrap().expect_job();
+            let job = shard.shift_remove(&self.key).unwrap().expect_job();
 
             shard.insert(self.key, QueryResult::Poisoned);
             job
@@ -344,7 +343,7 @@ where
     let current_job_id = qcx.current_query_job();
 
     match state_lock.entry(key) {
-        Entry::Vacant(entry) => {
+        IndexEntry::Vacant(entry) => {
             // Nothing has computed or is computing the query, so we start a new job and insert it in the
             // state map.
             let id = qcx.next_job_id();
@@ -356,7 +355,7 @@ where
 
             execute_job::<_, _, INCR>(query, qcx, state, key, id, dep_node)
         }
-        Entry::Occupied(mut entry) => {
+        IndexEntry::Occupied(mut entry) => {
             match entry.get_mut() {
                 QueryResult::Started(job) => {
                     #[cfg(parallel_compiler)]