Revert "Fix lint"

This reverts commit a81c05c.

Author: sgodwincs

src/list_ordered_multimap.rs

@@ -697,8 +697,9 @@ where
   /// assert_eq!(map.values_len(), 2);
   /// ```
   pub fn append(&mut self, key: Key, value: Value) -> bool {
-    let hash = self.build_hasher.hash_one(&key);
+    let hash = hash_key(&self.build_hasher, &key);
     let entry = raw_entry_mut(&self.keys, &mut self.map, hash, &key);
+    let build_hasher = &self.build_hasher;
 
     match entry {
       RawEntryMut::Occupied(mut entry) => {
@@ -722,7 +723,7 @@ where
         let keys = &self.keys;
         let _ = entry.insert_with_hasher(hash, key_index, MapEntry::new(index), |&key_index| {
           let key = keys.get(key_index).unwrap();
-          self.build_hasher.hash_one(key)
+          hash_key(build_hasher, key)
         });
         false
       }
@@ -749,7 +750,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
     raw_entry(&self.keys, &self.map, hash, key).is_some()
   }
 
@@ -769,7 +770,7 @@ where
   /// ```
   #[must_use]
   pub fn entry(&mut self, key: Key) -> Entry<'_, Key, Value, State> {
-    let hash = self.build_hasher.hash_one(&key);
+    let hash = hash_key(&self.build_hasher, &key);
 
     // TODO: This ugliness arises from borrow checking issues which seems to happen when the vacant entry is created in
     // the match block further below for `Vacant` even though it should be perfectly safe. Is there a better way to do
@@ -819,7 +820,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
 
     match raw_entry(&self.keys, &self.map, hash, key) {
       Some((_, map_entry)) => map_entry.length,
@@ -847,7 +848,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
     let (_, map_entry) = raw_entry(&self.keys, &self.map, hash, key)?;
     self
       .values
@@ -880,7 +881,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
 
     match raw_entry(&self.keys, &self.map, hash, key) {
       Some((_, map_entry)) => EntryValues::from_map_entry(&self.values, map_entry),
@@ -918,7 +919,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
 
     match raw_entry(&self.keys, &self.map, hash, key) {
       Some((_, map_entry)) => EntryValuesMut::from_map_entry(&mut self.values, map_entry),
@@ -953,7 +954,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
     let (_, map_entry) = raw_entry(&self.keys, &self.map, hash, key)?;
     self
       .values
@@ -1028,8 +1029,9 @@ where
   /// assert_eq!(map.get(&"key"), Some(&"value3"));
   /// ```
   pub fn insert_all(&mut self, key: Key, value: Value) -> EntryValuesDrain<'_, Key, Value> {
-    let hash = self.build_hasher.hash_one(&key);
+    let hash = hash_key(&self.build_hasher, &key);
     let entry = raw_entry_mut(&self.keys, &mut self.map, hash, &key);
+    let build_hasher = &self.build_hasher;
 
     match entry {
       RawEntryMut::Occupied(mut entry) => {
@@ -1048,7 +1050,7 @@ where
         let keys = &self.keys;
         let _ = entry.insert_with_hasher(hash, key_index, MapEntry::new(index), |&key_index| {
           let key = keys.get(key_index).unwrap();
-          self.build_hasher.hash_one(key)
+          hash_key(build_hasher, key)
         });
         EntryValuesDrain::empty(&mut self.values)
       }
@@ -1101,6 +1103,7 @@ where
     let key_map = self.keys.pack_to(keys_minimum_capacity);
     let value_map = self.values.pack_to(values_minimum_capacity);
     let mut map = HashMap::with_capacity_and_hasher(keys_minimum_capacity, DummyState);
+    let build_hasher = &self.build_hasher;
 
     for value_entry in self.values.iter_mut() {
       value_entry.key_index = key_map[&value_entry.key_index];
@@ -1113,14 +1116,14 @@ where
       map_entry.tail_index = value_map[&map_entry.tail_index];
       let key_index = key_map[&key_index];
       let key = self.keys.get(key_index).unwrap();
-      let hash = self.build_hasher.hash_one(key);
+      let hash = hash_key(&self.build_hasher, key);
 
       match map.raw_entry_mut().from_hash(hash, |_| false) {
         RawEntryMut::Vacant(entry) => {
           let keys = &self.keys;
           let _ = entry.insert_with_hasher(hash, key_index, map_entry, |&key_index| {
             let key = keys.get(key_index).unwrap();
-            self.build_hasher.hash_one(key)
+            hash_key(build_hasher, key)
           });
         }
         _ => panic!("expected vacant entry"),
@@ -1196,7 +1199,7 @@ where
     let key_wrapper = match value_entry.previous_index {
       Some(previous_index) => {
         let key = self.keys.get(value_entry.key_index).unwrap();
-        let hash = self.build_hasher.hash_one(key);
+        let hash = hash_key(&self.build_hasher, &key);
 
         let mut entry = match raw_entry_mut(&self.keys, &mut self.map, hash, key) {
           RawEntryMut::Occupied(entry) => entry,
@@ -1213,7 +1216,7 @@ where
       }
       None => {
         let key = self.keys.remove(value_entry.key_index).unwrap();
-        let hash = self.build_hasher.hash_one(&key);
+        let hash = hash_key(&self.build_hasher, &key);
 
         match raw_entry_mut_empty(&self.keys, &mut self.map, hash) {
           RawEntryMut::Occupied(entry) => {
@@ -1265,7 +1268,7 @@ where
     let key_wrapper = match value_entry.next_index {
       Some(next_index) => {
         let key = self.keys.get(value_entry.key_index).unwrap();
-        let hash = self.build_hasher.hash_one(key);
+        let hash = hash_key(&self.build_hasher, &key);
 
         let mut entry = match raw_entry_mut(&self.keys, &mut self.map, hash, key) {
           RawEntryMut::Occupied(entry) => entry,
@@ -1282,7 +1285,7 @@ where
       }
       None => {
         let key = self.keys.remove(value_entry.key_index).unwrap();
-        let hash = self.build_hasher.hash_one(&key);
+        let hash = hash_key(&self.build_hasher, &key);
 
         match raw_entry_mut_empty(&self.keys, &mut self.map, hash) {
           RawEntryMut::Occupied(entry) => {
@@ -1363,7 +1366,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
     let entry = raw_entry_mut(&self.keys, &mut self.map, hash, key);
 
     match entry {
@@ -1449,7 +1452,7 @@ where
     Key: Borrow<KeyQuery>,
     KeyQuery: ?Sized + Eq + Hash,
   {
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(&self.build_hasher, &key);
     let entry = raw_entry_mut(&self.keys, &mut self.map, hash, key);
 
     match entry {
@@ -1494,7 +1497,7 @@ where
 
     for (key_index, map_entry) in self.map.drain() {
       let key = self.keys.get(key_index).unwrap();
-      let hash = self.build_hasher.hash_one(key);
+      let hash = hash_key(&self.build_hasher, key);
       let entry = match raw_entry_mut(&self.keys, &mut map, hash, key) {
         RawEntryMut::Vacant(entry) => entry,
         _ => panic!("expected vacant entry"),
@@ -1560,7 +1563,7 @@ where
       if function(key, &mut value_entry.value) {
         true
       } else {
-        let hash = build_hasher.hash_one(key);
+        let hash = hash_key(build_hasher, key);
         let mut entry = match raw_entry_mut(keys, map, hash, key) {
           RawEntryMut::Occupied(entry) => entry,
           _ => panic!("expected occupied entry in internal map"),
@@ -2475,6 +2478,7 @@ where
   /// assert_eq!(entry.insert("value"), &"value");
   /// ```
   pub fn insert(self, value: Value) -> &'map mut Value {
+    let build_hasher = self.build_hasher;
     let entry = match raw_entry_mut(self.keys, self.map, self.hash, &self.key) {
       RawEntryMut::Vacant(entry) => entry,
       _ => panic!("expected vacant entry"),
@@ -2486,7 +2490,7 @@ where
     let keys = &self.keys;
     let _ = entry.insert_with_hasher(self.hash, key_index, map_entry, |&key_index| {
       let key = keys.get(key_index).unwrap();
-      self.build_hasher.hash_one(key)
+      hash_key(build_hasher, key)
     });
 
     &mut self.values.get_mut(index).unwrap().value
@@ -2509,6 +2513,7 @@ where
   /// assert_eq!(entry.get(), &"value");
   /// ```
   pub fn insert_entry(self, value: Value) -> OccupiedEntry<'map, Key, Value> {
+    let build_hasher = self.build_hasher;
     let entry = match raw_entry_mut(self.keys, self.map, self.hash, &self.key) {
       RawEntryMut::Vacant(entry) => entry,
       _ => panic!("expected vacant entry"),
@@ -2520,7 +2525,7 @@ where
     let keys = &self.keys;
     let _ = entry.insert_with_hasher(self.hash, key_index, map_entry, |&key_index| {
       let key = keys.get(key_index).unwrap();
-      self.build_hasher.hash_one(key)
+      hash_key(build_hasher, key)
     });
 
     let key = self.keys.get(key_index).unwrap();
@@ -3161,7 +3166,7 @@ where
 {
   fn next_back(&mut self) -> Option<Self::Item> {
     let key = self.iter.next_back()?;
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(self.build_hasher, key);
     let (_, map_entry) = raw_entry(self.keys, self.map, hash, key).unwrap();
     let iter = EntryValues::from_map_entry(self.values, map_entry);
     Some((key, iter))
@@ -3191,7 +3196,7 @@ where
 
   fn next(&mut self) -> Option<Self::Item> {
     let key = self.iter.next()?;
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(self.build_hasher, key);
     let (_, map_entry) = raw_entry(self.keys, self.map, hash, key).unwrap();
     let iter = EntryValues::from_map_entry(self.values, map_entry);
     Some((key, iter))
@@ -3255,7 +3260,7 @@ where
 {
   fn next_back(&mut self) -> Option<Self::Item> {
     let key = self.iter.next_back()?;
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(self.build_hasher, key);
     let (_, map_entry) = raw_entry(self.keys, self.map, hash, key).unwrap();
     let iter = EntryValuesMut::from_map_entry(unsafe { &mut *self.values }, map_entry);
     Some((key, iter))
@@ -3285,7 +3290,7 @@ where
 
   fn next(&mut self) -> Option<Self::Item> {
     let key = self.iter.next()?;
-    let hash = self.build_hasher.hash_one(key);
+    let hash = hash_key(self.build_hasher, key);
     let (_, map_entry) = raw_entry(self.keys, self.map, hash, key).unwrap();
     let iter = EntryValuesMut::from_map_entry(unsafe { &mut *self.values }, map_entry);
     Some((key, iter))
@@ -3469,6 +3474,18 @@ impl Hasher for DummyHasher {
   }
 }
 
+/// Computes the hash value of the given key.
+#[must_use]
+fn hash_key<KeyQuery, State>(state: &State, key: &KeyQuery) -> u64
+where
+  KeyQuery: ?Sized + Eq + Hash,
+  State: BuildHasher,
+{
+  let mut hasher = state.build_hasher();
+  key.hash(&mut hasher);
+  hasher.finish()
+}
+
 #[must_use]
 fn raw_entry<'map, Key, KeyQuery, Value, State>(
   keys: &VecList<Key>,
@@ -3570,7 +3587,7 @@ mod test {
     let mut map = ListOrderedMultimap::with_hasher(TestBuildHasher);
     let state = map.hasher();
 
-    assert_eq!(state.hash_one("key1"), state.hash_one("key2"));
+    assert_eq!(hash_key(state, "key1"), hash_key(state, "key2"));
 
     map.insert("key1", "value1");
     assert_eq!(map.get(&"key1"), Some(&"value1"));
@@ -3582,8 +3599,8 @@ mod test {
   #[test]
   fn test_no_collision() {
     let state = RandomState::new();
-    let hash_1 = state.hash_one("key1");
-    let hash_2 = state.hash_one("key2");
+    let hash_1 = hash_key(&state, "key1");
+    let hash_2 = hash_key(&state, "key2");
 
     assert!(hash_1 != hash_2);
   }