Clippy

src/eclass.rs

@@ -35,6 +35,7 @@ impl<L, D> EClass<L, D> {
     }
 
     /// Returns the number of enodes in this eclass.
+    #[allow(clippy::len_without_is_empty)] // https://github.com/rust-lang/rust-clippy/issues/11165
     pub fn len(&self) -> usize {
         self.nodes.len()
     }

src/egraph.rs

@@ -707,11 +707,7 @@ impl<L: Language, N: Analysis<L>> EGraph<L, N> {
             enode,
             |this, existing_id, enode| {
                 if let Some(explain) = this.explain.as_mut() {
-                    if let Some(existing_id) = explain.uncanon_memo.get(enode) {
-                        Some(*existing_id)
-                    } else {
-                        None
-                    }
+                    explain.uncanon_memo.get(enode).copied()
                 } else {
                     Some(existing_id)
                 }

src/explain.rs

@@ -1074,7 +1074,7 @@ impl<L: Language> Explain<L> {
         equalities
     }
 
-    pub(crate) fn with_raw_egraph<'a, X>(&'a mut self, raw: X) -> ExplainWith<'a, L, X> {
+    pub(crate) fn with_raw_egraph<X>(&mut self, raw: X) -> ExplainWith<'_, L, X> {
         ExplainWith { explain: self, raw }
     }
 }

src/raw/dhashmap.rs

@@ -53,21 +53,19 @@ fn hash_one(hasher: &impl BuildHasher, hash: impl Hash) -> u64 {
 }
 
 #[inline]
-fn eq<'a, K: Eq, V>(k: &'a K) -> impl Fn(&(K, V, DHMIdx)) -> bool + 'a {
+fn eq<K: Eq, V>(k: &K) -> impl Fn(&(K, V, DHMIdx)) -> bool + '_ {
     move |x| &x.0 == k
 }
 
 #[inline]
-fn hasher_fn<'a, K: Hash, V, S: BuildHasher>(
-    hasher: &'a S,
-) -> impl Fn(&(K, V, DHMIdx)) -> u64 + 'a {
+fn hasher_fn<K: Hash, V, S: BuildHasher>(hasher: &S) -> impl Fn(&(K, V, DHMIdx)) -> u64 + '_ {
     move |x| hash_one(hasher, &x.0)
 }
 
 impl<K: Hash + Eq, V, S: BuildHasher> DHashMap<K, V, S> {
     #[inline]
     pub(super) fn entry(&mut self, k: K) -> (Entry<'_, K, V>, u64) {
-        let hash = hash_one(&mut self.hasher, &k);
+        let hash = hash_one(&self.hasher, &k);
         let len = self.data.len() as DHMIdx;
         let entry = match self.data.entry(hash, eq(&k), hasher_fn(&self.hasher)) {
             hash_table::Entry::Occupied(entry) => Entry::Occupied((k, &mut entry.into_mut().1)),
@@ -136,7 +134,7 @@ impl<K: Hash + Eq, V, S: Default + BuildHasher> FromIterator<(K, V)> for DHashMa
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         let mut res = Self::default();
         iter.into_iter().for_each(|(k, v)| {
-            let hash = hash_one(&mut res.hasher, &k);
+            let hash = hash_one(&res.hasher, &k);
             res.insert_with_hash(hash, k, v)
         });
         res
@@ -158,6 +156,7 @@ mod test {
     #[derive(Eq, PartialEq, Debug, Clone)]
     struct BadHash<T>(T);
 
+    #[allow(clippy::derive_hash_xor_eq)] // We explicitly want to test a bad implementation
     impl<T> Hash for BadHash<T> {
         fn hash<H: Hasher>(&self, _: &mut H) {}
     }

src/raw/semi_persistent2.rs

@@ -166,7 +166,7 @@ impl<L: Language, D, U: AsUnwrap<UndoLog>> RawEGraph<L, D, U> {
         self.pop_memo2(memo_log_count);
         self.pop_parents2(pop_parents_count, node_count);
         self.pop_unions2(union_count, node_count, state, clear, mk_data, handle_eqv);
-        self.pop_nodes2(usize::from(node_count));
+        self.pop_nodes2(node_count);
     }
 
     fn pop_memo2(&mut self, old_count: usize) {