Use portable hash function for CacheKey (#7533)

crates/ruff_cache/src/cache_key.rs

@@ -1,41 +1,13 @@
 use std::borrow::Cow;
-use std::collections::hash_map::DefaultHasher;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::num::NonZeroU8;
-use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
 
 use glob::Pattern;
 use itertools::Itertools;
 use regex::Regex;
-
-#[derive(Clone, Debug, Default)]
-pub struct CacheKeyHasher {
-    inner: DefaultHasher,
-}
-
-impl CacheKeyHasher {
-    pub fn new() -> Self {
-        Self {
-            inner: DefaultHasher::new(),
-        }
-    }
-}
-
-impl Deref for CacheKeyHasher {
-    type Target = DefaultHasher;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl DerefMut for CacheKeyHasher {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
+use seahash::SeaHasher;
 
 /// A type that be used as part of a cache key.
 ///
@@ -255,14 +227,14 @@ impl_cache_key_tuple! { T B C D E F G H I J K L }
 impl CacheKey for str {
     #[inline]
     fn cache_key(&self, state: &mut CacheKeyHasher) {
-        self.hash(&mut **state);
+        self.hash(&mut *state);
     }
 }
 
 impl CacheKey for String {
     #[inline]
     fn cache_key(&self, state: &mut CacheKeyHasher) {
-        self.hash(&mut **state);
+        self.hash(&mut *state);
     }
 }
 
@@ -360,14 +332,14 @@ impl<K: CacheKey + Ord, V: CacheKey> CacheKey for BTreeMap<K, V> {
 impl CacheKey for Path {
     #[inline]
     fn cache_key(&self, state: &mut CacheKeyHasher) {
-        self.hash(&mut **state);
+        self.hash(&mut *state);
     }
 }
 
 impl CacheKey for PathBuf {
     #[inline]
     fn cache_key(&self, state: &mut CacheKeyHasher) {
-        self.hash(&mut **state);
+        self.as_path().cache_key(state);
     }
 }
 
@@ -391,3 +363,88 @@ impl CacheKey for Pattern {
         self.as_str().cache_key(state);
     }
 }
+
+#[derive(Clone, Default)]
+pub struct CacheKeyHasher {
+    inner: SeaHasher,
+}
+
+impl CacheKeyHasher {
+    pub fn new() -> Self {
+        Self {
+            inner: SeaHasher::new(),
+        }
+    }
+}
+
+impl Hasher for CacheKeyHasher {
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.inner.finish()
+    }
+
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        self.inner.write(bytes);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.inner.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.inner.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.inner.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.inner.write_u64(i);
+    }
+
+    #[inline]
+    fn write_u128(&mut self, i: u128) {
+        self.inner.write_u128(i);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.inner.write_usize(i);
+    }
+
+    #[inline]
+    fn write_i8(&mut self, i: i8) {
+        self.inner.write_i8(i);
+    }
+
+    #[inline]
+    fn write_i16(&mut self, i: i16) {
+        self.inner.write_i16(i);
+    }
+
+    #[inline]
+    fn write_i32(&mut self, i: i32) {
+        self.inner.write_i32(i);
+    }
+
+    #[inline]
+    fn write_i64(&mut self, i: i64) {
+        self.inner.write_i64(i);
+    }
+
+    #[inline]
+    fn write_i128(&mut self, i: i128) {
+        self.inner.write_i128(i);
+    }
+
+    #[inline]
+    fn write_isize(&mut self, i: isize) {
+        self.inner.write_isize(i);
+    }
+}

crates/ruff_cache/src/filetime.rs

@@ -6,6 +6,6 @@ use crate::{CacheKey, CacheKeyHasher};
 
 impl CacheKey for FileTime {
     fn cache_key(&self, state: &mut CacheKeyHasher) {
-        self.hash(&mut **state);
+        self.hash(&mut *state);
     }
 }