Allow the lint for somewhere which seems that ordering affects nothing

Author: ismailarilik

compiler/rustc_data_structures/src/sharded.rs

@@ -1,13 +1,12 @@
 use std::borrow::Borrow;
+use std::collections::hash_map::RawEntryMut;
 use std::hash::{Hash, Hasher};
 use std::{iter, mem};
 
 #[cfg(parallel_compiler)]
 use either::Either;
-use indexmap::map::RawEntryApiV1;
-use indexmap::map::raw_entry_v1::RawEntryMut;
 
-use crate::fx::{FxHasher, FxIndexMap};
+use crate::fx::{FxHashMap, FxHasher};
 #[cfg(parallel_compiler)]
 use crate::sync::{CacheAligned, is_dyn_thread_safe};
 use crate::sync::{Lock, LockGuard, Mode};
@@ -160,15 +159,15 @@ pub fn shards() -> usize {
     1
 }
 
-pub type ShardedIndexMap<K, V> = Sharded<FxIndexMap<K, V>>;
+pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
 
-impl<K: Eq, V> ShardedIndexMap<K, V> {
+impl<K: Eq, V> ShardedHashMap<K, V> {
     pub fn len(&self) -> usize {
         self.lock_shards().map(|shard| shard.len()).sum()
     }
 }
 
-impl<K: Eq + Hash + Copy> ShardedIndexMap<K, ()> {
+impl<K: Eq + Hash + Copy> ShardedHashMap<K, ()> {
     #[inline]
     pub fn intern_ref<Q: ?Sized>(&self, value: &Q, make: impl FnOnce() -> K) -> K
     where
@@ -177,7 +176,7 @@ impl<K: Eq + Hash + Copy> ShardedIndexMap<K, ()> {
     {
         let hash = make_hash(value);
         let mut shard = self.lock_shard_by_hash(hash);
-        let entry = shard.raw_entry_mut_v1().from_key_hashed_nocheck(hash, value);
+        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, value);
 
         match entry {
             RawEntryMut::Occupied(e) => *e.key(),
@@ -197,7 +196,7 @@ impl<K: Eq + Hash + Copy> ShardedIndexMap<K, ()> {
     {
         let hash = make_hash(&value);
         let mut shard = self.lock_shard_by_hash(hash);
-        let entry = shard.raw_entry_mut_v1().from_key_hashed_nocheck(hash, &value);
+        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, &value);
 
         match entry {
             RawEntryMut::Occupied(e) => *e.key(),
@@ -215,12 +214,12 @@ pub trait IntoPointer {
     fn into_pointer(&self) -> *const ();
 }
 
-impl<K: Eq + Hash + Copy + IntoPointer> ShardedIndexMap<K, ()> {
+impl<K: Eq + Hash + Copy + IntoPointer> ShardedHashMap<K, ()> {
     pub fn contains_pointer_to<T: Hash + IntoPointer>(&self, value: &T) -> bool {
         let hash = make_hash(&value);
         let shard = self.lock_shard_by_hash(hash);
         let value = value.into_pointer();
-        shard.raw_entry_v1().from_hash(hash, |entry| entry.into_pointer() == value).is_some()
+        shard.raw_entry().from_hash(hash, |entry| entry.into_pointer() == value).is_some()
     }
 }
 

compiler/rustc_middle/src/ty/context.rs

@@ -19,7 +19,7 @@ use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::profiling::SelfProfilerRef;
-use rustc_data_structures::sharded::{IntoPointer, ShardedIndexMap};
+use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::sync::{self, FreezeReadGuard, Lock, Lrc, RwLock, WorkerLocal};
@@ -742,7 +742,7 @@ impl<'tcx> rustc_type_ir::inherent::Span<TyCtxt<'tcx>> for Span {
     }
 }
 
-type InternedSet<'tcx, T> = ShardedIndexMap<InternedInSet<'tcx, T>, ()>;
+type InternedSet<'tcx, T> = ShardedHashMap<InternedInSet<'tcx, T>, ()>;
 
 pub struct CtxtInterners<'tcx> {
     /// The arena that types, regions, etc. are allocated from.
@@ -2242,6 +2242,8 @@ macro_rules! sty_debug_print {
                 $(let mut $variant = total;)*
 
                 for shard in tcx.interners.type_.lock_shards() {
+                    // It seems that ordering doesn't affect anything here.
+                    #[allow(rustc::potential_query_instability)]
                     let types = shard.keys();
                     for &InternedInSet(t) in types {
                         let variant = match t.internee {