Modify StableSet with a HashStable implementation.

Author: hameerabbasi

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -544,19 +544,6 @@ where
     }
 }
 
-impl<K, R, HCX> HashStable<HCX> for ::std::collections::HashSet<K, R>
-where
-    K: ToStableHashKey<HCX> + Eq,
-    R: BuildHasher,
-{
-    fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher) {
-        stable_hash_reduce(hcx, hasher, self.iter(), self.len(), |hasher, hcx, key| {
-            let key = key.to_stable_hash_key(hcx);
-            key.hash_stable(hcx, hasher);
-        });
-    }
-}
-
 impl<K, V, HCX> HashStable<HCX> for ::std::collections::BTreeMap<K, V>
 where
     K: ToStableHashKey<HCX>,
@@ -583,7 +570,7 @@ where
     }
 }
 
-fn stable_hash_reduce<HCX, I, C, F>(
+pub fn stable_hash_reduce<HCX, I, C, F>(
     hcx: &mut HCX,
     hasher: &mut StableHasher,
     mut collection: C,

compiler/rustc_data_structures/src/stable_set.rs

@@ -3,6 +3,8 @@ use std::borrow::Borrow;
 use std::fmt;
 use std::hash::Hash;
 
+use crate::stable_hasher::{stable_hash_reduce, HashStable, StableHasher, ToStableHashKey};
+
 /// A deterministic wrapper around FxHashSet that does not provide iteration support.
 ///
 /// It supports insert, remove, get functions from FxHashSet.
@@ -16,6 +18,7 @@ impl<T> Default for StableSet<T>
 where
     T: Eq + Hash,
 {
+    #[inline]
     fn default() -> StableSet<T> {
         StableSet::new()
     }
@@ -25,6 +28,7 @@ impl<T> fmt::Debug for StableSet<T>
 where
     T: Eq + Hash + fmt::Debug,
 {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", self.base)
     }
@@ -34,6 +38,7 @@ impl<T> PartialEq<StableSet<T>> for StableSet<T>
 where
     T: Eq + Hash,
 {
+    #[inline]
     fn eq(&self, other: &StableSet<T>) -> bool {
         self.base == other.base
     }
@@ -42,19 +47,22 @@ where
 impl<T> Eq for StableSet<T> where T: Eq + Hash {}
 
 impl<T: Hash + Eq> StableSet<T> {
+    #[inline]
     pub fn new() -> StableSet<T> {
         StableSet { base: FxHashSet::default() }
     }
 
-    pub fn into_sorted_vector(self) -> Vec<T>
+    #[inline]
+    pub fn into_sorted_vector<HCX>(self, hcx: &HCX) -> Vec<T>
     where
-        T: Ord,
+        T: ToStableHashKey<HCX>,
     {
         let mut vector = self.base.into_iter().collect::<Vec<_>>();
-        vector.sort_unstable();
+        vector.sort_by_cached_key(|x| x.to_stable_hash_key(hcx));
         vector
     }
 
+    #[inline]
     pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
     where
         T: Borrow<Q>,
@@ -63,15 +71,35 @@ impl<T: Hash + Eq> StableSet<T> {
         self.base.get(value)
     }
 
+    #[inline]
     pub fn insert(&mut self, value: T) -> bool {
         self.base.insert(value)
     }
 
+    #[inline]
     pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
     where
         T: Borrow<Q>,
         Q: Hash + Eq,
     {
         self.base.remove(value)
     }
+
+    #[inline]
+    pub fn contains(&self, value: &T) -> bool {
+        self.base.contains(value)
+    }
+}
+
+impl<T, HCX> HashStable<HCX> for StableSet<T>
+where
+    T: ToStableHashKey<HCX> + Eq,
+{
+    #[inline]
+    fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher) {
+        stable_hash_reduce(hcx, hasher, self.base.iter(), self.base.len(), |hasher, hcx, key| {
+            let key = key.to_stable_hash_key(hcx);
+            key.hash_stable(hcx, hasher);
+        });
+    }
 }