Fix serde and warnings

src/egraph.rs

@@ -850,12 +850,10 @@ impl<L: Language, N: Analysis<L>> EGraph<L, N> {
 
             let did_merge = self.analysis.merge(&mut info.data1.data, info.data2.data);
             if did_merge.0 {
-                self.analysis_pending
-                    .extend(info.parents1.into_iter().copied());
+                self.analysis_pending.extend(info.parents1.iter().copied());
             }
             if did_merge.1 {
-                self.analysis_pending
-                    .extend(info.parents2.into_iter().copied());
+                self.analysis_pending.extend(info.parents2.iter().copied());
             }
 
             concat_vecs(&mut info.data1.nodes, info.data2.nodes);

src/lib.rs

@@ -126,6 +126,8 @@ impl std::fmt::Display for Id {
 mod cid {
     /// Index into the classes field of an [`EGraph`]
     #[derive(Hash, Clone, Copy, Eq, PartialEq)]
+    #[cfg_attr(feature = "serde-1", derive(serde::Serialize, serde::Deserialize))]
+    #[cfg_attr(feature = "serde-1", serde(transparent))]
     pub struct ClassId(pub(crate) u32);
 
     impl std::fmt::Debug for ClassId {

src/raw/egraph.rs

@@ -582,7 +582,7 @@ impl<L: Language, D, U: UndoLogT<L, D>> RawEGraph<L, D, U> {
     }
 
     /// Similar to [`raw_add`](RawEGraph::raw_add) but takes an extra `pre_union`
-    /// closure that allows comparing the two [equal](Eq::eq) canonical nodes used to determine
+    /// closure that allows comparing the two [equal](PartialEq::eq) canonical nodes used to determine
     /// a congruent union. This can be useful in niche situations involving explanations when
     /// node canonization sorts children to make some discriminants symmetric
     ///
@@ -750,12 +750,15 @@ impl<L: Language, D, U: UndoLogT<L, D>> RawEGraph<L, D, U> {
         let _: Result<(), Infallible> = RawEGraph::try_raw_rebuild(
             outer,
             get_self,
-            |this, id1, id2| Ok(perform_union(this, id1, id2)),
+            |this, id1, id2| {
+                perform_union(this, id1, id2);
+                Ok(())
+            },
             handle_pending,
         );
     }
 
-    /// Similar to [`raw_rebuild`] but allows for the union operation to fail and abort the rebuild
+    /// Similar to [`raw_rebuild`](RawEGraph::raw_rebuild) but allows for the union operation to fail and abort the rebuild
     #[inline]
     pub fn try_raw_rebuild<T, E>(
         outer: &mut T,
@@ -773,7 +776,7 @@ impl<L: Language, D, U: UndoLogT<L, D>> RawEGraph<L, D, U> {
     }
 
     /// Similar to [`try_raw_rebuild`](RawEGraph::try_raw_rebuild) but takes an extra `pre_union`
-    /// closure that allows comparing the two [equal](Eq::eq) canonical nodes used to determine
+    /// closure that allows comparing the two [equal](PartialEq::eq) canonical nodes used to determine
     /// a congruent union. This can be useful in niche situations involving explanations when
     /// node canonization sorts children to make some discriminants symmetric
     #[inline]

src/raw/language.rs

@@ -83,19 +83,19 @@ impl<L: Language> IndexMut<Id> for RecExpr<L> {
     }
 }
 
-/// Trait that defines a Language whose terms will be in the [`EGraph`].
+/// Trait that defines a Language whose terms will be in the [`EGraph`](crate::raw::RawEGraph).
 ///
-/// Check out the [`define_language!`] macro for an easy way to create
+/// Check out the [`define_language!`](crate::define_language) macro for an easy way to create
 /// a [`Language`].
 ///
-/// If you want to pretty-print expressions, you should implement [`Display`] to
+/// If you want to pretty-print expressions, you should implement [`Display`](core::fmt::Display) to
 /// display the language node's operator. For example, a language node
 /// `Add([Id; 2])` might be displayed as "+".
 ///
-/// To parse expressions from strings you should also implement [`FromOp`].
+/// To parse expressions from strings you should also implement [`FromOp`](crate::FromOp).
 ///
-/// The [`define_language!`] macro automatically implements both [`Display`] and
-/// [`FromOp`].
+/// The [`define_language!`](crate::define_language)  macro automatically implements both
+/// [`Display`](core::fmt::Display) and [`FromOp`](crate::FromOp).
 ///
 /// See [`SymbolLang`] for quick-and-dirty use cases.
 #[allow(clippy::len_without_is_empty)]

src/raw/util.rs

@@ -13,5 +13,4 @@ mod hashmap {
     use super::BuildHasher;
     pub(crate) type HashMap<K, V> = hashbrown::HashMap<K, V, BuildHasher>;
     pub(crate) type HashSet<K> = hashbrown::HashSet<K, BuildHasher>;
-    pub(crate) type Entry<'a, K, V> = hashbrown::hash_map::Entry<'a, K, V, BuildHasher>;
 }