hashmap slab test

Author: laurmaedje

Cargo.toml

@@ -46,7 +46,6 @@ comemo-macros = { workspace = true, optional = true }
 parking_lot = { workspace = true }
 siphasher = { workspace = true }
 bumpalo = "*"
-slab = "0.4"
 
 [dev-dependencies]
 quickcheck = { workspace = true }

src/calltree.rs

@@ -2,8 +2,62 @@ use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use std::fmt::{self, Debug};
 use std::hash::Hash;
+use std::ops::{Index, IndexMut};
 
-use slab::Slab;
+/// A simple allocator.
+struct Slab<T> {
+    map: HashMap<usize, T>,
+    counter: usize,
+}
+
+impl<T> Slab<T> {
+    fn new() -> Self {
+        Self { map: HashMap::new(), counter: 0 }
+    }
+
+    #[cfg(test)]
+    fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    fn insert(&mut self, value: T) -> usize {
+        self.counter += 1;
+        self.map.insert(self.counter, value);
+        self.counter
+    }
+
+    fn contains(&self, i: usize) -> bool {
+        self.map.contains_key(&i)
+    }
+
+    fn retain(&mut self, mut f: impl FnMut(usize, &mut T) -> bool) {
+        self.map.retain(|i, v| f(*i, v));
+    }
+
+    fn remove(&mut self, i: usize) {
+        self.map.remove(&i);
+    }
+}
+
+impl<T> Index<usize> for Slab<T> {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.map[&index]
+    }
+}
+
+impl<T> IndexMut<usize> for Slab<T> {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        self.map.get_mut(&index).unwrap()
+    }
+}
+
+impl<T> Default for Slab<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 /// A deduplicated sequence of calls to tracked functions.
 ///