From 5861201a1f26c4f34ef63d2f452f6cc995e30651 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 13:02:58 +0100
Subject: [PATCH 01/12] Add interning arena

---
 stack-graphs/src/arena.rs      | 64 +++++++++++++++++++++++++++++++++-
 stack-graphs/tests/it/arena.rs | 15 ++++++++
 2 files changed, 78 insertions(+), 1 deletion(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 6feaa3f7d..b440ea96e 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -30,6 +30,8 @@
 //! [`StackGraph`]: ../graph/struct.StackGraph.html
 
 use std::cell::Cell;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::hash::Hasher;
@@ -195,7 +197,7 @@ impl<T> Arena<T> {
     pub fn get(&self, handle: Handle<T>) -> &T {
         unsafe { std::mem::transmute(&self.items[handle.as_usize()]) }
     }
-    ///
+
     /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
     /// it.
     pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
@@ -222,6 +224,66 @@ impl<T> Arena<T> {
     }
 }
 
+/// An interning arena allocation.  Equal handles means equal elements.
+pub struct InterningArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    arena: Arena<T>,
+    index: HashMap<T, Handle<T>>,
+}
+
+impl<T> InterningArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    /// Creates a new interning arena.
+    pub fn new() -> Self {
+        Self {
+            arena: Arena::new(),
+            index: HashMap::new(),
+        }
+    }
+
+    /// Adds a new instance to this arena, returning a stable handle to it.
+    ///
+    /// Note that we deduplicate instances of `T`.  If you add two instances that
+    /// have the same content, you will get identical handles for each one.
+    pub fn add(&mut self, item: T) -> Handle<T> {
+        match self.index.entry(item) {
+            Entry::Occupied(entry) => *entry.get(),
+            Entry::Vacant(entry) => {
+                let handle = self.arena.add(entry.key().clone());
+                entry.insert(handle);
+                handle
+            }
+        }
+    }
+
+    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
+    pub fn get(&self, handle: Handle<T>) -> &T {
+        self.arena.get(handle)
+    }
+
+    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
+    /// it.
+    pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
+        self.arena.get_mut(handle)
+    }
+
+    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
+    /// retain a reference to the arena!)
+    pub fn iter_handles(&self) -> impl Iterator<Item = Handle<T>> {
+        self.arena.iter_handles()
+    }
+
+    /// Returns the number of instances stored in this arena.
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.arena.len()
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Supplemental arenas
 
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 5af25d66e..7fe467f74 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -8,6 +8,7 @@
 use stack_graphs::arena::Arena;
 use stack_graphs::arena::Deque;
 use stack_graphs::arena::DequeArena;
+use stack_graphs::arena::InterningArena;
 use stack_graphs::arena::List;
 use stack_graphs::arena::ListArena;
 use stack_graphs::arena::ReversibleList;
@@ -229,3 +230,17 @@ fn can_compare_deques() {
     deque10.ensure_backwards(&mut arena);
     assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
 }
+
+#[test]
+fn can_allocate_in_interning_arena() {
+    let mut arena = InterningArena::new();
+    let hello1 = arena.add("hello".to_string());
+    let hello2 = arena.add("hello".to_string());
+    let there = arena.add("there".to_string());
+    assert_eq!(hello1, hello2);
+    assert_ne!(hello1, there);
+    assert_ne!(hello2, there);
+    assert_eq!(arena.get(hello1), arena.get(hello2));
+    assert_ne!(arena.get(hello1), arena.get(there));
+    assert_ne!(arena.get(hello2), arena.get(there));
+}

From 2acf77798c1e55844f43dce7ef228b0e098aca33 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 13:34:15 +0100
Subject: [PATCH 02/12] Introduce arena trait

---
 stack-graphs/src/arena.rs      | 136 +++++++++++++++++++++------------
 stack-graphs/src/c.rs          |   1 +
 stack-graphs/src/graph.rs      |  17 +++--
 stack-graphs/src/stitching.rs  |   5 +-
 stack-graphs/tests/it/arena.rs |   9 ++-
 5 files changed, 105 insertions(+), 63 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index b440ea96e..4b014729e 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -40,6 +40,7 @@ use std::mem::MaybeUninit;
 use std::num::NonZeroU32;
 use std::ops::Index;
 use std::ops::IndexMut;
+use std::ops::Range;
 
 use bitvec::vec::BitVec;
 use controlled_option::Niche;
@@ -159,14 +160,62 @@ impl<T> PartialOrd for Handle<T> {
 unsafe impl<T> Send for Handle<T> {}
 unsafe impl<T> Sync for Handle<T> {}
 
+pub struct Handles<T> {
+    range: Range<usize>,
+    _phantom: PhantomData<T>,
+}
+
+impl<T> Iterator for Handles<T> {
+    type Item = Handle<T>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.range
+            .next()
+            .map(|index| Handle::new(unsafe { NonZeroU32::new_unchecked(index as u32) }))
+    }
+}
+
+impl<T> From<Range<usize>> for Handles<T> {
+    fn from(range: Range<usize>) -> Self {
+        Handles {
+            range,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+pub trait Arena<T> {
+    /// Adds a new instance to this arena, returning a stable handle to it.
+    fn add(&mut self, item: T) -> Handle<T>;
+
+    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
+    fn get(&self, handle: Handle<T>) -> &T;
+
+    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
+    /// it.
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T;
+
+    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
+    /// retain a reference to the arena!)
+    fn iter_handles(&self) -> Handles<T>;
+
+    /// Returns a pointer to this arena's storage.
+    fn as_ptr(&self) -> *const T;
+
+    /// Returns the number of instances stored in this arena.
+    fn len(&self) -> usize;
+}
+
 /// Manages the life cycle of instances of type `T`.  You can allocate new instances of `T` from
 /// the arena.  All of the instances managed by this arena will be dropped as a single operation
 /// when the arena itself is dropped.
-pub struct Arena<T> {
+///
+/// Note that we do not deduplicate instances of `T` in any way.  If you add two instances that
+/// have the same content, you will get distinct handles for each one.
+pub struct VecArena<T> {
     items: Vec<MaybeUninit<T>>,
 }
 
-impl<T> Drop for Arena<T> {
+impl<T> Drop for VecArena<T> {
     fn drop(&mut self) {
         unsafe {
             let items = std::mem::transmute::<_, &mut [T]>(&mut self.items[1..]) as *mut [T];
@@ -175,81 +224,71 @@ impl<T> Drop for Arena<T> {
     }
 }
 
-impl<T> Arena<T> {
+impl<T> VecArena<T> {
     /// Creates a new arena.
-    pub fn new() -> Arena<T> {
-        Arena {
+    pub fn new() -> VecArena<T> {
+        VecArena {
             items: vec![MaybeUninit::uninit()],
         }
     }
+}
 
-    /// Adds a new instance to this arena, returning a stable handle to it.
-    ///
-    /// Note that we do not deduplicate instances of `T` in any way.  If you add two instances that
-    /// have the same content, you will get distinct handles for each one.
-    pub fn add(&mut self, item: T) -> Handle<T> {
+impl<T> Arena<T> for VecArena<T> {
+    fn add(&mut self, item: T) -> Handle<T> {
         let index = self.items.len() as u32;
         self.items.push(MaybeUninit::new(item));
         Handle::new(unsafe { NonZeroU32::new_unchecked(index) })
     }
 
-    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
-    pub fn get(&self, handle: Handle<T>) -> &T {
+    fn get(&self, handle: Handle<T>) -> &T {
         unsafe { std::mem::transmute(&self.items[handle.as_usize()]) }
     }
 
-    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
-    /// it.
-    pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
         unsafe { std::mem::transmute(&mut self.items[handle.as_usize()]) }
     }
 
-    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
-    /// retain a reference to the arena!)
-    pub fn iter_handles(&self) -> impl Iterator<Item = Handle<T>> {
-        (1..self.items.len())
-            .into_iter()
-            .map(|index| Handle::new(unsafe { NonZeroU32::new_unchecked(index as u32) }))
+    fn iter_handles(&self) -> Handles<T> {
+        (1..self.items.len()).into()
     }
 
-    /// Returns a pointer to this arena's storage.
-    pub(crate) fn as_ptr(&self) -> *const T {
+    fn as_ptr(&self) -> *const T {
         self.items.as_ptr() as *const T
     }
 
-    /// Returns the number of instances stored in this arena.
     #[inline(always)]
-    pub fn len(&self) -> usize {
+    fn len(&self) -> usize {
         self.items.len()
     }
 }
 
 /// An interning arena allocation.  Equal handles means equal elements.
-pub struct InterningArena<T>
+pub struct HashArena<T>
 where
     T: Clone + Eq + Hash,
 {
-    arena: Arena<T>,
+    arena: VecArena<T>,
     index: HashMap<T, Handle<T>>,
 }
 
-impl<T> InterningArena<T>
+impl<T> HashArena<T>
 where
     T: Clone + Eq + Hash,
 {
     /// Creates a new interning arena.
     pub fn new() -> Self {
         Self {
-            arena: Arena::new(),
+            arena: VecArena::new(),
             index: HashMap::new(),
         }
     }
+}
 
-    /// Adds a new instance to this arena, returning a stable handle to it.
-    ///
-    /// Note that we deduplicate instances of `T`.  If you add two instances that
-    /// have the same content, you will get identical handles for each one.
-    pub fn add(&mut self, item: T) -> Handle<T> {
+impl<T> Arena<T> for HashArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    fn add(&mut self, item: T) -> Handle<T> {
         match self.index.entry(item) {
             Entry::Occupied(entry) => *entry.get(),
             Entry::Vacant(entry) => {
@@ -260,26 +299,24 @@ where
         }
     }
 
-    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
-    pub fn get(&self, handle: Handle<T>) -> &T {
+    fn get(&self, handle: Handle<T>) -> &T {
         self.arena.get(handle)
     }
 
-    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
-    /// it.
-    pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
         self.arena.get_mut(handle)
     }
 
-    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
-    /// retain a reference to the arena!)
-    pub fn iter_handles(&self) -> impl Iterator<Item = Handle<T>> {
+    fn iter_handles(&self) -> Handles<T> {
         self.arena.iter_handles()
     }
 
-    /// Returns the number of instances stored in this arena.
+    fn as_ptr(&self) -> *const T {
+        self.arena.as_ptr()
+    }
+
     #[inline(always)]
-    pub fn len(&self) -> usize {
+    fn len(&self) -> usize {
         self.arena.len()
     }
 }
@@ -299,8 +336,9 @@ where
 /// ```
 /// # use stack_graphs::arena::Arena;
 /// # use stack_graphs::arena::SupplementalArena;
+/// # use stack_graphs::arena::VecArena;
 /// // We need an Arena to create handles.
-/// let mut arena = Arena::<u32>::new();
+/// let mut arena = VecArena::<u32>::new();
 /// let handle = arena.add(1);
 ///
 /// let mut supplemental = SupplementalArena::<u32, String>::new();
@@ -344,8 +382,8 @@ impl<H, T> SupplementalArena<H, T> {
 
     /// Creates a new, empty supplemental arena, preallocating enough space to store supplemental
     /// data for all of the instances that have already been allocated in a (regular) arena.
-    pub fn with_capacity(arena: &Arena<H>) -> SupplementalArena<H, T> {
-        let mut items = Vec::with_capacity(arena.items.len());
+    pub fn with_capacity(arena: impl Arena<H>) -> SupplementalArena<H, T> {
+        let mut items = Vec::with_capacity(arena.len());
         items[0] = MaybeUninit::uninit();
         SupplementalArena {
             items,
@@ -531,7 +569,7 @@ const EMPTY_LIST_HANDLE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(u32::MA
 //
 // (Note that the arena doesn't store `List<T>` itself; it stores the `ListCell<T>`s that the lists
 // are made of.)
-pub type ListArena<T> = Arena<ListCell<T>>;
+pub type ListArena<T> = VecArena<ListCell<T>>;
 
 impl<T> List<T> {
     /// Creates a new `ListArena` that will manage lists of this type.
@@ -682,7 +720,7 @@ pub struct ReversibleListCell<T> {
 //
 // (Note that the arena doesn't store `ReversibleList<T>` itself; it stores the
 // `ReversibleListCell<T>`s that the lists are made of.)
-pub type ReversibleListArena<T> = Arena<ReversibleListCell<T>>;
+pub type ReversibleListArena<T> = VecArena<ReversibleListCell<T>>;
 
 impl<T> ReversibleList<T> {
     /// Creates a new `ReversibleListArena` that will manage lists of this type.
diff --git a/stack-graphs/src/c.rs b/stack-graphs/src/c.rs
index 998d4cf2e..c0dd6177a 100644
--- a/stack-graphs/src/c.rs
+++ b/stack-graphs/src/c.rs
@@ -14,6 +14,7 @@ use std::sync::atomic::AtomicUsize;
 
 use libc::c_char;
 
+use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::graph::File;
 use crate::graph::InternedString;
diff --git a/stack-graphs/src/graph.rs b/stack-graphs/src/graph.rs
index 6eb0f8c34..4e9e57e1e 100644
--- a/stack-graphs/src/graph.rs
+++ b/stack-graphs/src/graph.rs
@@ -63,6 +63,7 @@ use smallvec::SmallVec;
 use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::arena::SupplementalArena;
+use crate::arena::VecArena;
 
 //-------------------------------------------------------------------------------------------------
 // String content
@@ -1401,13 +1402,13 @@ impl StackGraph {
 /// Contains all of the nodes and edges that make up a stack graph.
 pub struct StackGraph {
     interned_strings: InternedStringArena,
-    pub(crate) symbols: Arena<Symbol>,
+    pub(crate) symbols: VecArena<Symbol>,
     symbol_handles: FxHashMap<&'static str, Handle<Symbol>>,
-    pub(crate) strings: Arena<InternedString>,
+    pub(crate) strings: VecArena<InternedString>,
     string_handles: FxHashMap<&'static str, Handle<InternedString>>,
-    pub(crate) files: Arena<File>,
+    pub(crate) files: VecArena<File>,
     file_handles: FxHashMap<&'static str, Handle<File>>,
-    pub(crate) nodes: Arena<Node>,
+    pub(crate) nodes: VecArena<Node>,
     pub(crate) source_info: SupplementalArena<Node, SourceInfo>,
     node_id_handles: NodeIDHandles,
     outgoing_edges: SupplementalArena<Node, SmallVec<[OutgoingEdge; 8]>>,
@@ -1573,17 +1574,17 @@ impl StackGraph {
 
 impl Default for StackGraph {
     fn default() -> StackGraph {
-        let mut nodes = Arena::new();
+        let mut nodes = VecArena::new();
         nodes.add(RootNode::new().into());
         nodes.add(JumpToNode::new().into());
 
         StackGraph {
             interned_strings: InternedStringArena::new(),
-            symbols: Arena::new(),
+            symbols: VecArena::new(),
             symbol_handles: FxHashMap::default(),
-            strings: Arena::new(),
+            strings: VecArena::new(),
             string_handles: FxHashMap::default(),
-            files: Arena::new(),
+            files: VecArena::new(),
             file_handles: FxHashMap::default(),
             nodes,
             source_info: SupplementalArena::new(),
diff --git a/stack-graphs/src/stitching.rs b/stack-graphs/src/stitching.rs
index 5de928324..cd1a61084 100644
--- a/stack-graphs/src/stitching.rs
+++ b/stack-graphs/src/stitching.rs
@@ -48,6 +48,7 @@ use crate::arena::List;
 use crate::arena::ListArena;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
+use crate::arena::VecArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
@@ -74,7 +75,7 @@ use crate::CancellationFlag;
 /// partial paths that are actually needed, placing them into a `Database` instance as they're
 /// needed.
 pub struct Database {
-    pub(crate) partial_paths: Arena<PartialPath>,
+    pub(crate) partial_paths: VecArena<PartialPath>,
     pub(crate) local_nodes: HandleSet<Node>,
     symbol_stack_keys: ListArena<Handle<Symbol>>,
     symbol_stack_key_cache: HashMap<SymbolStackCacheKey, SymbolStackKeyHandle>,
@@ -86,7 +87,7 @@ impl Database {
     /// Creates a new, empty database.
     pub fn new() -> Database {
         Database {
-            partial_paths: Arena::new(),
+            partial_paths: VecArena::new(),
             local_nodes: HandleSet::new(),
             symbol_stack_keys: List::new_arena(),
             symbol_stack_key_cache: HashMap::new(),
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 7fe467f74..8b7faac8d 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -8,16 +8,17 @@
 use stack_graphs::arena::Arena;
 use stack_graphs::arena::Deque;
 use stack_graphs::arena::DequeArena;
-use stack_graphs::arena::InterningArena;
+use stack_graphs::arena::HashArena;
 use stack_graphs::arena::List;
 use stack_graphs::arena::ListArena;
 use stack_graphs::arena::ReversibleList;
 use stack_graphs::arena::ReversibleListArena;
 use stack_graphs::arena::SupplementalArena;
+use stack_graphs::arena::VecArena;
 
 #[test]
 fn can_allocate_in_arena() {
-    let mut arena = Arena::new();
+    let mut arena = VecArena::new();
     let hello1 = arena.add("hello".to_string());
     let hello2 = arena.add("hello".to_string());
     let there = arena.add("there".to_string());
@@ -31,7 +32,7 @@ fn can_allocate_in_arena() {
 
 #[test]
 fn can_allocate_in_supplemental_arena() {
-    let mut arena = Arena::<u32>::new();
+    let mut arena = VecArena::<u32>::new();
     let h1 = arena.add(1);
     let h2 = arena.add(2);
     let h3 = arena.add(3);
@@ -233,7 +234,7 @@ fn can_compare_deques() {
 
 #[test]
 fn can_allocate_in_interning_arena() {
-    let mut arena = InterningArena::new();
+    let mut arena = HashArena::new();
     let hello1 = arena.add("hello".to_string());
     let hello2 = arena.add("hello".to_string());
     let there = arena.add("there".to_string());

From 9f674479f093e8cbfddcf0ae649028a4bca8d31b Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 14:15:52 +0100
Subject: [PATCH 03/12] Support any Arena for ReversibleList

---
 stack-graphs/src/arena.rs | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 4b014729e..fdf38f3ec 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -716,16 +716,12 @@ pub struct ReversibleListCell<T> {
     reversed: Cell<Option<Handle<ReversibleListCell<T>>>>,
 }
 
-// An arena that's used to manage `ReversibleList<T>` instances.
-//
-// (Note that the arena doesn't store `ReversibleList<T>` itself; it stores the
-// `ReversibleListCell<T>`s that the lists are made of.)
 pub type ReversibleListArena<T> = VecArena<ReversibleListCell<T>>;
 
 impl<T> ReversibleList<T> {
-    /// Creates a new `ReversibleListArena` that will manage lists of this type.
+    /// Creates a new arena that will manage lists of this type.
     pub fn new_arena() -> ReversibleListArena<T> {
-        ReversibleListArena::new()
+        VecArena::new()
     }
 
     /// Returns whether this list is empty.
@@ -765,12 +761,11 @@ impl<T> ReversibleList<T> {
         self.cells = cell.tail;
         Some(&cell.head)
     }
+}
 
+impl<'a, T: 'a> ReversibleList<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter<'a>(
-        mut self,
-        arena: &'a ReversibleListArena<T>,
-    ) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(mut self, arena: &'a ReversibleListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
 }
@@ -997,7 +992,7 @@ pub type DequeArena<T> = ReversibleListArena<T>;
 impl<T> Deque<T> {
     /// Creates a new `DequeArena` that will manage deques of this type.
     pub fn new_arena() -> DequeArena<T> {
-        ReversibleList::new_arena()
+        VecArena::new()
     }
 
     /// Returns whether this deque is empty.

From cb6f651ad53c7131b150aa8409208a7dec39195a Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 14:30:32 +0100
Subject: [PATCH 04/12] Support any Arena for Deque

---
 stack-graphs/src/arena.rs      | 143 ++++++++++++++++++++-------------
 stack-graphs/src/partial.rs    |  16 ++--
 stack-graphs/tests/it/arena.rs |  23 +++---
 3 files changed, 107 insertions(+), 75 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index fdf38f3ec..85605666d 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -716,11 +716,9 @@ pub struct ReversibleListCell<T> {
     reversed: Cell<Option<Handle<ReversibleListCell<T>>>>,
 }
 
-pub type ReversibleListArena<T> = VecArena<ReversibleListCell<T>>;
-
 impl<T> ReversibleList<T> {
     /// Creates a new arena that will manage lists of this type.
-    pub fn new_arena() -> ReversibleListArena<T> {
+    pub fn new_arena() -> impl Arena<ReversibleListCell<T>> {
         VecArena::new()
     }
 
@@ -738,7 +736,7 @@ impl<T> ReversibleList<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this list.
-    pub fn have_reversal(&self, arena: &ReversibleListArena<T>) -> bool {
+    pub fn have_reversal(&self, arena: &impl Arena<ReversibleListCell<T>>) -> bool {
         if self.is_empty() {
             // The empty list is already reversed.
             return true;
@@ -747,13 +745,13 @@ impl<T> ReversibleList<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut ReversibleListArena<T>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl Arena<ReversibleListCell<T>>, head: T) {
         self.cells = arena.add(ReversibleListCell::new(head, self.cells, None));
     }
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a ReversibleListArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl Arena<ReversibleListCell<T>>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -765,7 +763,10 @@ impl<T> ReversibleList<T> {
 
 impl<'a, T: 'a> ReversibleList<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter(mut self, arena: &'a ReversibleListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(
+        mut self,
+        arena: &'a impl Arena<ReversibleListCell<T>>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
 }
@@ -777,7 +778,7 @@ where
     /// Reverses the list.  Since we're already caching everything in an arena, we make sure to
     /// only calculate the reversal once, returning it as-is if you call this function multiple
     /// times.
-    pub fn reverse(&mut self, arena: &mut ReversibleListArena<T>) {
+    pub fn reverse(&mut self, arena: &mut impl Arena<ReversibleListCell<T>>) {
         if self.is_empty() {
             return;
         }
@@ -788,7 +789,7 @@ where
     /// Ensures that the reversal of this list is available.  It can be useful to precalculate this
     /// when you have mutable access to the arena, so that you can then reverse and un-reverse the
     /// list later when you only have shared access to it.
-    pub fn ensure_reversal_available(&self, arena: &mut ReversibleListArena<T>) {
+    pub fn ensure_reversal_available(&self, arena: &mut impl Arena<ReversibleListCell<T>>) {
         // First check to see if the list has already been reversed.
         if self.is_empty() {
             // The empty list is already reversed.
@@ -807,7 +808,7 @@ where
 impl<T> ReversibleList<T> {
     /// Reverses the list, assuming that the reversal has already been computed.  If it hasn't we
     /// return an error.
-    pub fn reverse_reused(&mut self, arena: &ReversibleListArena<T>) -> Result<(), ()> {
+    pub fn reverse_reused(&mut self, arena: &impl Arena<ReversibleListCell<T>>) -> Result<(), ()> {
         if self.is_empty() {
             // The empty list is already reversed.
             return Ok(());
@@ -845,7 +846,7 @@ where
 {
     fn reverse(
         forwards: Handle<ReversibleListCell<T>>,
-        arena: &mut ReversibleListArena<T>,
+        arena: &mut impl Arena<ReversibleListCell<T>>,
     ) -> Handle<ReversibleListCell<T>> {
         let mut reversed = ReversibleListCell::empty_handle();
         let mut current = forwards;
@@ -872,7 +873,7 @@ where
 impl<T> ReversibleList<T> {
     pub fn equals_with<F>(
         mut self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl Arena<ReversibleListCell<T>>,
         mut other: ReversibleList<T>,
         mut eq: F,
     ) -> bool
@@ -891,7 +892,7 @@ impl<T> ReversibleList<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl Arena<ReversibleListCell<T>>,
         mut other: ReversibleList<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -915,7 +916,11 @@ impl<T> ReversibleList<T>
 where
     T: Eq,
 {
-    pub fn equals(self, arena: &ReversibleListArena<T>, other: ReversibleList<T>) -> bool {
+    pub fn equals(
+        self,
+        arena: &impl Arena<ReversibleListCell<T>>,
+        other: ReversibleList<T>,
+    ) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -926,7 +931,7 @@ where
 {
     pub fn cmp(
         self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl Arena<ReversibleListCell<T>>,
         other: ReversibleList<T>,
     ) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
@@ -948,6 +953,8 @@ impl<T> Copy for ReversibleList<T> {}
 //-------------------------------------------------------------------------------------------------
 // Arena-allocated deque
 
+pub type DequeCell<T> = ReversibleListCell<T>;
+
 /// An arena-allocated deque.
 ///
 /// Under the covers, this is implemented as a [`List`][].  Because these lists are singly-linked,
@@ -986,12 +993,9 @@ impl std::ops::Not for DequeDirection {
     }
 }
 
-// An arena that's used to manage `Deque<T>` instances.
-pub type DequeArena<T> = ReversibleListArena<T>;
-
 impl<T> Deque<T> {
-    /// Creates a new `DequeArena` that will manage deques of this type.
-    pub fn new_arena() -> DequeArena<T> {
+    /// Creates a new arena that will manage deques of this type.
+    pub fn new_arena() -> impl Arena<DequeCell<T>> {
         VecArena::new()
     }
 
@@ -1014,7 +1018,7 @@ impl<T> Deque<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this deque.
-    pub fn have_reversal(&self, arena: &DequeArena<T>) -> bool {
+    pub fn have_reversal(&self, arena: &impl Arena<DequeCell<T>>) -> bool {
         self.list.have_reversal(arena)
     }
 
@@ -1025,12 +1029,17 @@ impl<T> Deque<T> {
     fn is_forwards(&self) -> bool {
         matches!(self.direction, DequeDirection::Forwards)
     }
+}
 
+impl<'a, T: 'a> Deque<T> {
     /// Returns an iterator over the contents of this deque, with no guarantee about the ordering of
     /// the elements.  (By not caring about the ordering of the elements, you can call this method
     /// regardless of which direction the deque's elements are currently stored.  And that, in
     /// turn, means that we only need shared access to the arena, and not mutable access to it.)
-    pub fn iter_unordered<'a>(&self, arena: &'a DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter_unordered(
+        &self,
+        arena: &'a impl Arena<DequeCell<T>>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
         self.list.iter(arena)
     }
 }
@@ -1040,7 +1049,7 @@ where
     T: Clone,
 {
     /// Ensures that this deque has computed its backwards-facing list of elements.
-    pub fn ensure_backwards(&mut self, arena: &mut DequeArena<T>) {
+    pub fn ensure_backwards(&mut self, arena: &mut impl Arena<DequeCell<T>>) {
         if self.is_backwards() {
             return;
         }
@@ -1049,7 +1058,7 @@ where
     }
 
     /// Ensures that this deque has computed its forwards-facing list of elements.
-    pub fn ensure_forwards(&mut self, arena: &mut DequeArena<T>) {
+    pub fn ensure_forwards(&mut self, arena: &mut impl Arena<DequeCell<T>>) {
         if self.is_forwards() {
             return;
         }
@@ -1058,38 +1067,67 @@ where
     }
 
     /// Ensures that this deque has computed both directions of elements.
-    pub fn ensure_both_directions(&self, arena: &mut DequeArena<T>) {
+    pub fn ensure_both_directions(&self, arena: &mut impl Arena<DequeCell<T>>) {
         self.list.ensure_reversal_available(arena);
     }
 
     /// Pushes a new element onto the front of this deque.
-    pub fn push_front(&mut self, arena: &mut DequeArena<T>, element: T) {
+    pub fn push_front(&mut self, arena: &mut impl Arena<DequeCell<T>>, element: T) {
         self.ensure_forwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Pushes a new element onto the back of this deque.
-    pub fn push_back(&mut self, arena: &mut DequeArena<T>, element: T) {
+    pub fn push_back(&mut self, arena: &mut impl Arena<DequeCell<T>>, element: T) {
         self.ensure_backwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Removes and returns the element from the front of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a mut DequeArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a mut impl Arena<DequeCell<T>>) -> Option<&'a T> {
         self.ensure_forwards(arena);
         self.list.pop_front(arena)
     }
 
     /// Removes and returns the element from the back of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_back<'a>(&mut self, arena: &'a mut DequeArena<T>) -> Option<&'a T> {
+    pub fn pop_back<'a>(&mut self, arena: &'a mut impl Arena<DequeCell<T>>) -> Option<&'a T> {
         self.ensure_backwards(arena);
         self.list.pop_front(arena)
     }
 
+    /// Ensures that both deques are stored in the same direction.  It doesn't matter _which_
+    /// direction, as long as they're the same, so do the minimum amount of work to bring this
+    /// about.  (In particular, if we've already calculated the reversal of one of the deques,
+    /// reverse that one.)
+    fn ensure_same_direction(
+        &mut self,
+        arena: &mut impl Arena<DequeCell<T>>,
+        other: &mut Deque<T>,
+    ) {
+        if self.direction == other.direction {
+            return;
+        }
+        if self.list.have_reversal(arena) {
+            self.list.reverse(arena);
+            self.direction = !self.direction;
+        } else {
+            other.list.reverse(arena);
+            other.direction = !other.direction;
+        }
+    }
+}
+
+impl<'a, T: 'a> Deque<T>
+where
+    T: Clone,
+{
     /// Returns an iterator over the contents of this deque in a forwards direction.
-    pub fn iter<'a>(&self, arena: &'a mut DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(
+        &self,
+        arena: &'a mut impl Arena<DequeCell<T>>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse(arena);
@@ -1098,9 +1136,9 @@ where
     }
 
     /// Returns an iterator over the contents of this deque in a backwards direction.
-    pub fn iter_reversed<'a>(
+    pub fn iter_reversed(
         &self,
-        arena: &'a mut DequeArena<T>,
+        arena: &'a mut impl Arena<DequeCell<T>>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
@@ -1108,30 +1146,18 @@ where
         }
         list.iter(arena)
     }
-
-    /// Ensures that both deques are stored in the same direction.  It doesn't matter _which_
-    /// direction, as long as they're the same, so do the minimum amount of work to bring this
-    /// about.  (In particular, if we've already calculated the reversal of one of the deques,
-    /// reverse that one.)
-    fn ensure_same_direction(&mut self, arena: &mut DequeArena<T>, other: &mut Deque<T>) {
-        if self.direction == other.direction {
-            return;
-        }
-        if self.list.have_reversal(arena) {
-            self.list.reverse(arena);
-            self.direction = !self.direction;
-        } else {
-            other.list.reverse(arena);
-            other.direction = !other.direction;
-        }
-    }
 }
 
 impl<T> Deque<T>
 where
     T: Clone,
 {
-    pub fn equals_with<F>(mut self, arena: &mut DequeArena<T>, mut other: Deque<T>, eq: F) -> bool
+    pub fn equals_with<F>(
+        mut self,
+        arena: &mut impl Arena<DequeCell<T>>,
+        mut other: Deque<T>,
+        eq: F,
+    ) -> bool
     where
         F: FnMut(&T, &T) -> bool,
     {
@@ -1141,7 +1167,7 @@ where
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &mut DequeArena<T>,
+        arena: &mut impl Arena<DequeCell<T>>,
         mut other: Deque<T>,
         cmp: F,
     ) -> std::cmp::Ordering
@@ -1160,7 +1186,7 @@ impl<T> Deque<T>
 where
     T: Clone + Eq,
 {
-    pub fn equals(self, arena: &mut DequeArena<T>, other: Deque<T>) -> bool {
+    pub fn equals(self, arena: &mut impl Arena<DequeCell<T>>, other: Deque<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -1169,18 +1195,21 @@ impl<T> Deque<T>
 where
     T: Clone + Ord,
 {
-    pub fn cmp(self, arena: &mut DequeArena<T>, other: Deque<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &mut impl Arena<DequeCell<T>>, other: Deque<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
 
-impl<T> Deque<T> {
+impl<'a, T: 'a> Deque<T> {
     /// Returns an iterator over the contents of this deque in a forwards direction, assuming that
     /// we have already computed its forwards-facing list of elements via [`ensure_forwards`][].
     /// Panics if we haven't already computed it.
     ///
     /// [`ensure_forwards`]: #method.ensure_forwards
-    pub fn iter_reused<'a>(&self, arena: &'a DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter_reused(
+        &self,
+        arena: &'a impl Arena<DequeCell<T>>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse_reused(arena)
@@ -1194,9 +1223,9 @@ impl<T> Deque<T> {
     /// Panics if we haven't already computed it.
     ///
     /// [`ensure_backwards`]: #method.ensure_backwards
-    pub fn iter_reversed_reused<'a>(
+    pub fn iter_reversed_reused(
         &self,
-        arena: &'a DequeArena<T>,
+        arena: &'a impl Arena<DequeCell<T>>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index a012c9bc0..ebd697996 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -44,10 +44,10 @@ use enumset::EnumSetType;
 use smallvec::SmallVec;
 
 use crate::arena::Deque;
-use crate::arena::DequeArena;
+use crate::arena::DequeCell;
 use crate::arena::Handle;
 use crate::arena::ReversibleList;
-use crate::arena::ReversibleListArena;
+use crate::arena::VecArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::graph::Edge;
@@ -2672,17 +2672,17 @@ struct Join {
 /// Manages the state of a collection of partial paths built up as part of the partial-path-finding
 /// algorithm or path-stitching algorithm.
 pub struct PartialPaths {
-    pub(crate) partial_symbol_stacks: ReversibleListArena<PartialScopedSymbol>,
-    pub(crate) partial_scope_stacks: ReversibleListArena<Handle<Node>>,
-    pub(crate) partial_path_edges: DequeArena<PartialPathEdge>,
+    pub(crate) partial_symbol_stacks: VecArena<DequeCell<PartialScopedSymbol>>,
+    pub(crate) partial_scope_stacks: VecArena<DequeCell<Handle<Node>>>,
+    pub(crate) partial_path_edges: VecArena<DequeCell<PartialPathEdge>>,
 }
 
 impl PartialPaths {
     pub fn new() -> PartialPaths {
         PartialPaths {
-            partial_symbol_stacks: ReversibleList::new_arena(),
-            partial_scope_stacks: ReversibleList::new_arena(),
-            partial_path_edges: Deque::new_arena(),
+            partial_symbol_stacks: VecArena::new(),
+            partial_scope_stacks: VecArena::new(),
+            partial_path_edges: VecArena::new(),
         }
     }
 }
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 8b7faac8d..18d3d5930 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -7,12 +7,12 @@
 
 use stack_graphs::arena::Arena;
 use stack_graphs::arena::Deque;
-use stack_graphs::arena::DequeArena;
+use stack_graphs::arena::DequeCell;
 use stack_graphs::arena::HashArena;
 use stack_graphs::arena::List;
 use stack_graphs::arena::ListArena;
 use stack_graphs::arena::ReversibleList;
-use stack_graphs::arena::ReversibleListArena;
+use stack_graphs::arena::ReversibleListCell;
 use stack_graphs::arena::SupplementalArena;
 use stack_graphs::arena::VecArena;
 
@@ -91,7 +91,10 @@ fn can_compare_lists() {
 
 #[test]
 fn can_create_reversible_lists() {
-    fn collect(list: &ReversibleList<u32>, arena: &ReversibleListArena<u32>) -> Vec<u32> {
+    fn collect(
+        list: &ReversibleList<u32>,
+        arena: &impl Arena<ReversibleListCell<u32>>,
+    ) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
 
@@ -148,13 +151,13 @@ fn can_compare_reversible_lists() {
 
 #[test]
 fn can_create_deques() {
-    fn collect(deque: &Deque<u32>, arena: &mut DequeArena<u32>) -> Vec<u32> {
+    fn collect(deque: &Deque<u32>, arena: &mut impl Arena<DequeCell<u32>>) -> Vec<u32> {
         deque.iter(arena).copied().collect()
     }
-    fn collect_reused(deque: &Deque<u32>, arena: &DequeArena<u32>) -> Vec<u32> {
+    fn collect_reused(deque: &Deque<u32>, arena: &impl Arena<DequeCell<u32>>) -> Vec<u32> {
         deque.iter_reused(arena).copied().collect()
     }
-    fn collect_rev(deque: &Deque<u32>, arena: &mut DequeArena<u32>) -> Vec<u32> {
+    fn collect_rev(deque: &Deque<u32>, arena: &mut impl Arena<DequeCell<u32>>) -> Vec<u32> {
         deque.iter_reversed(arena).copied().collect()
     }
 
@@ -192,20 +195,20 @@ fn can_compare_deques() {
     let mut arena = Deque::new_arena();
     // Build up deques in both directions so that our comparisons have to test the "reverse if
     // needed" logic.
-    let from_slice_forwards = |slice: &[u32], arena: &mut DequeArena<u32>| {
+    fn from_slice_forwards(slice: &[u32], arena: &mut impl Arena<DequeCell<u32>>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter() {
             deque.push_back(arena, *element);
         }
         deque
-    };
-    let from_slice_backwards = |slice: &[u32], arena: &mut DequeArena<u32>| {
+    }
+    fn from_slice_backwards(slice: &[u32], arena: &mut impl Arena<DequeCell<u32>>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter().rev() {
             deque.push_front(arena, *element);
         }
         deque
-    };
+    }
     let deque0 = from_slice_forwards(&[], &mut arena);
     let mut deque1 = from_slice_backwards(&[1], &mut arena);
     let deque2 = from_slice_forwards(&[2], &mut arena);

From b7780985b1854d7c195941bf8320e0e7382d4de4 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 14:38:04 +0100
Subject: [PATCH 05/12] Support any Arena for List

---
 stack-graphs/src/arena.rs      | 33 +++++++++++++++++----------------
 stack-graphs/src/cycles.rs     |  5 +++--
 stack-graphs/src/stitching.rs  |  5 ++---
 stack-graphs/tests/it/arena.rs |  4 ++--
 4 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 85605666d..45024a863 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -565,16 +565,10 @@ pub struct ListCell<T> {
 
 const EMPTY_LIST_HANDLE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(u32::MAX) };
 
-// An arena that's used to manage `List<T>` instances.
-//
-// (Note that the arena doesn't store `List<T>` itself; it stores the `ListCell<T>`s that the lists
-// are made of.)
-pub type ListArena<T> = VecArena<ListCell<T>>;
-
 impl<T> List<T> {
-    /// Creates a new `ListArena` that will manage lists of this type.
-    pub fn new_arena() -> ListArena<T> {
-        ListArena::new()
+    /// Creates a new arena that will manage lists of this type.
+    pub fn new_arena() -> impl Arena<ListCell<T>> {
+        VecArena::new()
     }
 
     /// Returns whether this list is empty.
@@ -600,7 +594,7 @@ impl<T> List<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut ListArena<T>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl Arena<ListCell<T>>, head: T) {
         self.cells = arena.add(ListCell {
             head,
             tail: self.cells,
@@ -609,7 +603,7 @@ impl<T> List<T> {
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a ListArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl Arena<ListCell<T>>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -617,15 +611,22 @@ impl<T> List<T> {
         self.cells = cell.tail;
         Some(&cell.head)
     }
+}
 
+impl<'a, T: 'a> List<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter<'a>(mut self, arena: &'a ListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(mut self, arena: &'a impl Arena<ListCell<T>>) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
 }
 
 impl<T> List<T> {
-    pub fn equals_with<F>(mut self, arena: &ListArena<T>, mut other: List<T>, mut eq: F) -> bool
+    pub fn equals_with<F>(
+        mut self,
+        arena: &impl Arena<ListCell<T>>,
+        mut other: List<T>,
+        mut eq: F,
+    ) -> bool
     where
         F: FnMut(&T, &T) -> bool,
     {
@@ -641,7 +642,7 @@ impl<T> List<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &ListArena<T>,
+        arena: &impl Arena<ListCell<T>>,
         mut other: List<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -665,7 +666,7 @@ impl<T> List<T>
 where
     T: Eq,
 {
-    pub fn equals(self, arena: &ListArena<T>, other: List<T>) -> bool {
+    pub fn equals(self, arena: &impl Arena<ListCell<T>>, other: List<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -674,7 +675,7 @@ impl<T> List<T>
 where
     T: Ord,
 {
-    pub fn cmp(self, arena: &ListArena<T>, other: List<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &impl Arena<ListCell<T>>, other: List<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
diff --git a/stack-graphs/src/cycles.rs b/stack-graphs/src/cycles.rs
index eb4577c6a..43e1dbf76 100644
--- a/stack-graphs/src/cycles.rs
+++ b/stack-graphs/src/cycles.rs
@@ -35,7 +35,8 @@ use std::collections::HashMap;
 
 use crate::arena::Handle;
 use crate::arena::List;
-use crate::arena::ListArena;
+use crate::arena::ListCell;
+use crate::arena::VecArena;
 use crate::graph::Edge;
 use crate::graph::Node;
 use crate::graph::StackGraph;
@@ -148,7 +149,7 @@ pub struct AppendingCycleDetector<A> {
     appendages: List<A>,
 }
 
-pub type Appendables<A> = ListArena<A>;
+pub type Appendables<A> = VecArena<ListCell<A>>;
 
 impl<A: Appendable + Clone> AppendingCycleDetector<A> {
     pub fn new() -> Self {
diff --git a/stack-graphs/src/stitching.rs b/stack-graphs/src/stitching.rs
index cd1a61084..4865a69db 100644
--- a/stack-graphs/src/stitching.rs
+++ b/stack-graphs/src/stitching.rs
@@ -45,7 +45,6 @@ use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::arena::HandleSet;
 use crate::arena::List;
-use crate::arena::ListArena;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
 use crate::arena::VecArena;
@@ -77,7 +76,7 @@ use crate::CancellationFlag;
 pub struct Database {
     pub(crate) partial_paths: VecArena<PartialPath>,
     pub(crate) local_nodes: HandleSet<Node>,
-    symbol_stack_keys: ListArena<Handle<Symbol>>,
+    symbol_stack_keys: VecArena<ListCell<Handle<Symbol>>>,
     symbol_stack_key_cache: HashMap<SymbolStackCacheKey, SymbolStackKeyHandle>,
     paths_by_start_node: SupplementalArena<Node, Vec<Handle<PartialPath>>>,
     root_paths_by_precondition: SupplementalArena<SymbolStackKeyCell, Vec<Handle<PartialPath>>>,
@@ -89,7 +88,7 @@ impl Database {
         Database {
             partial_paths: VecArena::new(),
             local_nodes: HandleSet::new(),
-            symbol_stack_keys: List::new_arena(),
+            symbol_stack_keys: VecArena::new(),
             symbol_stack_key_cache: HashMap::new(),
             paths_by_start_node: SupplementalArena::new(),
             root_paths_by_precondition: SupplementalArena::new(),
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 18d3d5930..9f2066c25 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -10,7 +10,7 @@ use stack_graphs::arena::Deque;
 use stack_graphs::arena::DequeCell;
 use stack_graphs::arena::HashArena;
 use stack_graphs::arena::List;
-use stack_graphs::arena::ListArena;
+use stack_graphs::arena::ListCell;
 use stack_graphs::arena::ReversibleList;
 use stack_graphs::arena::ReversibleListCell;
 use stack_graphs::arena::SupplementalArena;
@@ -47,7 +47,7 @@ fn can_allocate_in_supplemental_arena() {
 
 #[test]
 fn can_create_lists() {
-    fn collect(list: &List<u32>, arena: &ListArena<u32>) -> Vec<u32> {
+    fn collect(list: &List<u32>, arena: &impl Arena<ListCell<u32>>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
 

From 0a00cc9b6b560eb2e691c617c84eb3ae59de0710 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 14:51:26 +0100
Subject: [PATCH 06/12] Bring back nice arena types

---
 stack-graphs/src/arena.rs      | 104 ++++++++++++++++-----------------
 stack-graphs/tests/it/arena.rs |  23 ++++----
 2 files changed, 61 insertions(+), 66 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 45024a863..7f7e63443 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -563,11 +563,15 @@ pub struct ListCell<T> {
     tail: Handle<ListCell<T>>,
 }
 
+pub trait ListArena<T>: Arena<ListCell<T>> {}
+
+impl<T, A> ListArena<T> for A where A: Arena<ListCell<T>> {}
+
 const EMPTY_LIST_HANDLE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(u32::MAX) };
 
 impl<T> List<T> {
     /// Creates a new arena that will manage lists of this type.
-    pub fn new_arena() -> impl Arena<ListCell<T>> {
+    pub fn new_arena() -> impl ListArena<T> {
         VecArena::new()
     }
 
@@ -594,7 +598,7 @@ impl<T> List<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut impl Arena<ListCell<T>>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl ListArena<T>, head: T) {
         self.cells = arena.add(ListCell {
             head,
             tail: self.cells,
@@ -603,7 +607,7 @@ impl<T> List<T> {
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a impl Arena<ListCell<T>>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl ListArena<T>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -615,7 +619,7 @@ impl<T> List<T> {
 
 impl<'a, T: 'a> List<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter(mut self, arena: &'a impl Arena<ListCell<T>>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(mut self, arena: &'a impl ListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
 }
@@ -623,7 +627,7 @@ impl<'a, T: 'a> List<T> {
 impl<T> List<T> {
     pub fn equals_with<F>(
         mut self,
-        arena: &impl Arena<ListCell<T>>,
+        arena: &impl ListArena<T>,
         mut other: List<T>,
         mut eq: F,
     ) -> bool
@@ -642,7 +646,7 @@ impl<T> List<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &impl Arena<ListCell<T>>,
+        arena: &impl ListArena<T>,
         mut other: List<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -666,7 +670,7 @@ impl<T> List<T>
 where
     T: Eq,
 {
-    pub fn equals(self, arena: &impl Arena<ListCell<T>>, other: List<T>) -> bool {
+    pub fn equals(self, arena: &impl ListArena<T>, other: List<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -675,7 +679,7 @@ impl<T> List<T>
 where
     T: Ord,
 {
-    pub fn cmp(self, arena: &impl Arena<ListCell<T>>, other: List<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &impl ListArena<T>, other: List<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
@@ -717,9 +721,13 @@ pub struct ReversibleListCell<T> {
     reversed: Cell<Option<Handle<ReversibleListCell<T>>>>,
 }
 
+pub trait ReversibleListArena<T>: Arena<ReversibleListCell<T>> {}
+
+impl<T, A> ReversibleListArena<T> for A where A: Arena<ReversibleListCell<T>> {}
+
 impl<T> ReversibleList<T> {
     /// Creates a new arena that will manage lists of this type.
-    pub fn new_arena() -> impl Arena<ReversibleListCell<T>> {
+    pub fn new_arena() -> impl ReversibleListArena<T> {
         VecArena::new()
     }
 
@@ -737,7 +745,7 @@ impl<T> ReversibleList<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this list.
-    pub fn have_reversal(&self, arena: &impl Arena<ReversibleListCell<T>>) -> bool {
+    pub fn have_reversal(&self, arena: &impl ReversibleListArena<T>) -> bool {
         if self.is_empty() {
             // The empty list is already reversed.
             return true;
@@ -746,13 +754,13 @@ impl<T> ReversibleList<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut impl Arena<ReversibleListCell<T>>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl ReversibleListArena<T>, head: T) {
         self.cells = arena.add(ReversibleListCell::new(head, self.cells, None));
     }
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a impl Arena<ReversibleListCell<T>>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl ReversibleListArena<T>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -766,7 +774,7 @@ impl<'a, T: 'a> ReversibleList<T> {
     /// Returns an iterator over the elements of this list.
     pub fn iter(
         mut self,
-        arena: &'a impl Arena<ReversibleListCell<T>>,
+        arena: &'a impl ReversibleListArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
@@ -779,7 +787,7 @@ where
     /// Reverses the list.  Since we're already caching everything in an arena, we make sure to
     /// only calculate the reversal once, returning it as-is if you call this function multiple
     /// times.
-    pub fn reverse(&mut self, arena: &mut impl Arena<ReversibleListCell<T>>) {
+    pub fn reverse(&mut self, arena: &mut impl ReversibleListArena<T>) {
         if self.is_empty() {
             return;
         }
@@ -790,7 +798,7 @@ where
     /// Ensures that the reversal of this list is available.  It can be useful to precalculate this
     /// when you have mutable access to the arena, so that you can then reverse and un-reverse the
     /// list later when you only have shared access to it.
-    pub fn ensure_reversal_available(&self, arena: &mut impl Arena<ReversibleListCell<T>>) {
+    pub fn ensure_reversal_available(&self, arena: &mut impl ReversibleListArena<T>) {
         // First check to see if the list has already been reversed.
         if self.is_empty() {
             // The empty list is already reversed.
@@ -809,7 +817,7 @@ where
 impl<T> ReversibleList<T> {
     /// Reverses the list, assuming that the reversal has already been computed.  If it hasn't we
     /// return an error.
-    pub fn reverse_reused(&mut self, arena: &impl Arena<ReversibleListCell<T>>) -> Result<(), ()> {
+    pub fn reverse_reused(&mut self, arena: &impl ReversibleListArena<T>) -> Result<(), ()> {
         if self.is_empty() {
             // The empty list is already reversed.
             return Ok(());
@@ -847,7 +855,7 @@ where
 {
     fn reverse(
         forwards: Handle<ReversibleListCell<T>>,
-        arena: &mut impl Arena<ReversibleListCell<T>>,
+        arena: &mut impl ReversibleListArena<T>,
     ) -> Handle<ReversibleListCell<T>> {
         let mut reversed = ReversibleListCell::empty_handle();
         let mut current = forwards;
@@ -874,7 +882,7 @@ where
 impl<T> ReversibleList<T> {
     pub fn equals_with<F>(
         mut self,
-        arena: &impl Arena<ReversibleListCell<T>>,
+        arena: &impl ReversibleListArena<T>,
         mut other: ReversibleList<T>,
         mut eq: F,
     ) -> bool
@@ -893,7 +901,7 @@ impl<T> ReversibleList<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &impl Arena<ReversibleListCell<T>>,
+        arena: &impl ReversibleListArena<T>,
         mut other: ReversibleList<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -917,11 +925,7 @@ impl<T> ReversibleList<T>
 where
     T: Eq,
 {
-    pub fn equals(
-        self,
-        arena: &impl Arena<ReversibleListCell<T>>,
-        other: ReversibleList<T>,
-    ) -> bool {
+    pub fn equals(self, arena: &impl ReversibleListArena<T>, other: ReversibleList<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -932,7 +936,7 @@ where
 {
     pub fn cmp(
         self,
-        arena: &impl Arena<ReversibleListCell<T>>,
+        arena: &impl ReversibleListArena<T>,
         other: ReversibleList<T>,
     ) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
@@ -956,6 +960,10 @@ impl<T> Copy for ReversibleList<T> {}
 
 pub type DequeCell<T> = ReversibleListCell<T>;
 
+pub trait DequeArena<T>: Arena<DequeCell<T>> {}
+
+impl<T, A> DequeArena<T> for A where A: Arena<DequeCell<T>> {}
+
 /// An arena-allocated deque.
 ///
 /// Under the covers, this is implemented as a [`List`][].  Because these lists are singly-linked,
@@ -996,7 +1004,7 @@ impl std::ops::Not for DequeDirection {
 
 impl<T> Deque<T> {
     /// Creates a new arena that will manage deques of this type.
-    pub fn new_arena() -> impl Arena<DequeCell<T>> {
+    pub fn new_arena() -> impl DequeArena<T> {
         VecArena::new()
     }
 
@@ -1019,7 +1027,7 @@ impl<T> Deque<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this deque.
-    pub fn have_reversal(&self, arena: &impl Arena<DequeCell<T>>) -> bool {
+    pub fn have_reversal(&self, arena: &impl DequeArena<T>) -> bool {
         self.list.have_reversal(arena)
     }
 
@@ -1039,7 +1047,7 @@ impl<'a, T: 'a> Deque<T> {
     /// turn, means that we only need shared access to the arena, and not mutable access to it.)
     pub fn iter_unordered(
         &self,
-        arena: &'a impl Arena<DequeCell<T>>,
+        arena: &'a impl DequeArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         self.list.iter(arena)
     }
@@ -1050,7 +1058,7 @@ where
     T: Clone,
 {
     /// Ensures that this deque has computed its backwards-facing list of elements.
-    pub fn ensure_backwards(&mut self, arena: &mut impl Arena<DequeCell<T>>) {
+    pub fn ensure_backwards(&mut self, arena: &mut impl DequeArena<T>) {
         if self.is_backwards() {
             return;
         }
@@ -1059,7 +1067,7 @@ where
     }
 
     /// Ensures that this deque has computed its forwards-facing list of elements.
-    pub fn ensure_forwards(&mut self, arena: &mut impl Arena<DequeCell<T>>) {
+    pub fn ensure_forwards(&mut self, arena: &mut impl DequeArena<T>) {
         if self.is_forwards() {
             return;
         }
@@ -1073,27 +1081,27 @@ where
     }
 
     /// Pushes a new element onto the front of this deque.
-    pub fn push_front(&mut self, arena: &mut impl Arena<DequeCell<T>>, element: T) {
+    pub fn push_front(&mut self, arena: &mut impl DequeArena<T>, element: T) {
         self.ensure_forwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Pushes a new element onto the back of this deque.
-    pub fn push_back(&mut self, arena: &mut impl Arena<DequeCell<T>>, element: T) {
+    pub fn push_back(&mut self, arena: &mut impl DequeArena<T>, element: T) {
         self.ensure_backwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Removes and returns the element from the front of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a mut impl Arena<DequeCell<T>>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a mut impl DequeArena<T>) -> Option<&'a T> {
         self.ensure_forwards(arena);
         self.list.pop_front(arena)
     }
 
     /// Removes and returns the element from the back of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_back<'a>(&mut self, arena: &'a mut impl Arena<DequeCell<T>>) -> Option<&'a T> {
+    pub fn pop_back<'a>(&mut self, arena: &'a mut impl DequeArena<T>) -> Option<&'a T> {
         self.ensure_backwards(arena);
         self.list.pop_front(arena)
     }
@@ -1102,11 +1110,7 @@ where
     /// direction, as long as they're the same, so do the minimum amount of work to bring this
     /// about.  (In particular, if we've already calculated the reversal of one of the deques,
     /// reverse that one.)
-    fn ensure_same_direction(
-        &mut self,
-        arena: &mut impl Arena<DequeCell<T>>,
-        other: &mut Deque<T>,
-    ) {
+    fn ensure_same_direction(&mut self, arena: &mut impl DequeArena<T>, other: &mut Deque<T>) {
         if self.direction == other.direction {
             return;
         }
@@ -1125,10 +1129,7 @@ where
     T: Clone,
 {
     /// Returns an iterator over the contents of this deque in a forwards direction.
-    pub fn iter(
-        &self,
-        arena: &'a mut impl Arena<DequeCell<T>>,
-    ) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(&self, arena: &'a mut impl DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse(arena);
@@ -1139,7 +1140,7 @@ where
     /// Returns an iterator over the contents of this deque in a backwards direction.
     pub fn iter_reversed(
         &self,
-        arena: &'a mut impl Arena<DequeCell<T>>,
+        arena: &'a mut impl DequeArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
@@ -1155,7 +1156,7 @@ where
 {
     pub fn equals_with<F>(
         mut self,
-        arena: &mut impl Arena<DequeCell<T>>,
+        arena: &mut impl DequeArena<T>,
         mut other: Deque<T>,
         eq: F,
     ) -> bool
@@ -1168,7 +1169,7 @@ where
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &mut impl Arena<DequeCell<T>>,
+        arena: &mut impl DequeArena<T>,
         mut other: Deque<T>,
         cmp: F,
     ) -> std::cmp::Ordering
@@ -1187,7 +1188,7 @@ impl<T> Deque<T>
 where
     T: Clone + Eq,
 {
-    pub fn equals(self, arena: &mut impl Arena<DequeCell<T>>, other: Deque<T>) -> bool {
+    pub fn equals(self, arena: &mut impl DequeArena<T>, other: Deque<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -1196,7 +1197,7 @@ impl<T> Deque<T>
 where
     T: Clone + Ord,
 {
-    pub fn cmp(self, arena: &mut impl Arena<DequeCell<T>>, other: Deque<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &mut impl DequeArena<T>, other: Deque<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
@@ -1207,10 +1208,7 @@ impl<'a, T: 'a> Deque<T> {
     /// Panics if we haven't already computed it.
     ///
     /// [`ensure_forwards`]: #method.ensure_forwards
-    pub fn iter_reused(
-        &self,
-        arena: &'a impl Arena<DequeCell<T>>,
-    ) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter_reused(&self, arena: &'a impl DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse_reused(arena)
@@ -1226,7 +1224,7 @@ impl<'a, T: 'a> Deque<T> {
     /// [`ensure_backwards`]: #method.ensure_backwards
     pub fn iter_reversed_reused(
         &self,
-        arena: &'a impl Arena<DequeCell<T>>,
+        arena: &'a impl DequeArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 9f2066c25..6364deb7d 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -7,12 +7,12 @@
 
 use stack_graphs::arena::Arena;
 use stack_graphs::arena::Deque;
-use stack_graphs::arena::DequeCell;
+use stack_graphs::arena::DequeArena;
 use stack_graphs::arena::HashArena;
 use stack_graphs::arena::List;
-use stack_graphs::arena::ListCell;
+use stack_graphs::arena::ListArena;
 use stack_graphs::arena::ReversibleList;
-use stack_graphs::arena::ReversibleListCell;
+use stack_graphs::arena::ReversibleListArena;
 use stack_graphs::arena::SupplementalArena;
 use stack_graphs::arena::VecArena;
 
@@ -47,7 +47,7 @@ fn can_allocate_in_supplemental_arena() {
 
 #[test]
 fn can_create_lists() {
-    fn collect(list: &List<u32>, arena: &impl Arena<ListCell<u32>>) -> Vec<u32> {
+    fn collect(list: &List<u32>, arena: &impl ListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
 
@@ -91,10 +91,7 @@ fn can_compare_lists() {
 
 #[test]
 fn can_create_reversible_lists() {
-    fn collect(
-        list: &ReversibleList<u32>,
-        arena: &impl Arena<ReversibleListCell<u32>>,
-    ) -> Vec<u32> {
+    fn collect(list: &ReversibleList<u32>, arena: &impl ReversibleListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
 
@@ -151,13 +148,13 @@ fn can_compare_reversible_lists() {
 
 #[test]
 fn can_create_deques() {
-    fn collect(deque: &Deque<u32>, arena: &mut impl Arena<DequeCell<u32>>) -> Vec<u32> {
+    fn collect(deque: &Deque<u32>, arena: &mut impl DequeArena<u32>) -> Vec<u32> {
         deque.iter(arena).copied().collect()
     }
-    fn collect_reused(deque: &Deque<u32>, arena: &impl Arena<DequeCell<u32>>) -> Vec<u32> {
+    fn collect_reused(deque: &Deque<u32>, arena: &impl DequeArena<u32>) -> Vec<u32> {
         deque.iter_reused(arena).copied().collect()
     }
-    fn collect_rev(deque: &Deque<u32>, arena: &mut impl Arena<DequeCell<u32>>) -> Vec<u32> {
+    fn collect_rev(deque: &Deque<u32>, arena: &mut impl DequeArena<u32>) -> Vec<u32> {
         deque.iter_reversed(arena).copied().collect()
     }
 
@@ -195,14 +192,14 @@ fn can_compare_deques() {
     let mut arena = Deque::new_arena();
     // Build up deques in both directions so that our comparisons have to test the "reverse if
     // needed" logic.
-    fn from_slice_forwards(slice: &[u32], arena: &mut impl Arena<DequeCell<u32>>) -> Deque<u32> {
+    fn from_slice_forwards(slice: &[u32], arena: &mut impl DequeArena<u32>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter() {
             deque.push_back(arena, *element);
         }
         deque
     }
-    fn from_slice_backwards(slice: &[u32], arena: &mut impl Arena<DequeCell<u32>>) -> Deque<u32> {
+    fn from_slice_backwards(slice: &[u32], arena: &mut impl DequeArena<u32>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter().rev() {
             deque.push_front(arena, *element);

From d7e108e41872f17295c00751d223a0836086094d Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Mon, 13 Mar 2023 19:10:15 +0100
Subject: [PATCH 07/12] Add traits to various arena types

---
 stack-graphs/src/arena.rs   | 20 +++++++++++--
 stack-graphs/src/partial.rs | 58 +++++++++++++++++++++++++++++++++----
 2 files changed, 71 insertions(+), 7 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 7f7e63443..613f6e474 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -546,7 +546,7 @@ impl<T> Default for HandleSet<T> {
 /// linked list implementation _should_ be cache-friendly, since the individual cells are allocated
 /// out of an arena.
 #[repr(C)]
-#[derive(Niche)]
+#[derive(Eq, Hash, Niche, PartialEq)]
 pub struct List<T> {
     // The value of this handle will be EMPTY_LIST_HANDLE if the list is empty.  For an
     // Option<List<T>>, the value will be zero (via the Option<NonZero> optimization) if the list
@@ -557,6 +557,7 @@ pub struct List<T> {
 
 #[doc(hidden)]
 #[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct ListCell<T> {
     head: T,
     // The value of this handle will be EMPTY_LIST_HANDLE if this is the last element of the list.
@@ -707,7 +708,7 @@ impl<T> Copy for List<T> {}
 ///
 /// [`List`]: struct.List.html
 #[repr(C)]
-#[derive(Niche)]
+#[derive(Eq, Hash, Niche, PartialEq)]
 pub struct ReversibleList<T> {
     #[niche]
     cells: Handle<ReversibleListCell<T>>,
@@ -715,12 +716,26 @@ pub struct ReversibleList<T> {
 
 #[repr(C)]
 #[doc(hidden)]
+#[derive(Clone, Eq)]
 pub struct ReversibleListCell<T> {
     head: T,
     tail: Handle<ReversibleListCell<T>>,
     reversed: Cell<Option<Handle<ReversibleListCell<T>>>>,
 }
 
+impl<T: Hash> Hash for ReversibleListCell<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.head.hash(state);
+        self.tail.hash(state);
+    }
+}
+
+impl<T: Eq> PartialEq for ReversibleListCell<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.head == other.head && self.tail == other.tail
+    }
+}
+
 pub trait ReversibleListArena<T>: Arena<ReversibleListCell<T>> {}
 
 impl<T, A> ReversibleListArena<T> for A where A: Arena<ReversibleListCell<T>> {}
@@ -980,6 +995,7 @@ impl<T, A> DequeArena<T> for A where A: Arena<DequeCell<T>> {}
 ///
 /// [`List`]: struct.List.html
 #[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct Deque<T> {
     list: ReversibleList<T>,
     direction: DequeDirection,
diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index ebd697996..4d996e7b9 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -158,8 +158,8 @@ where
 
 /// Represents an unknown list of scoped symbols.
 #[repr(transparent)]
-#[derive(Clone, Copy, Debug, Eq, Hash, Niche, Ord, PartialEq, PartialOrd)]
-pub struct SymbolStackVariable(#[niche] NonZeroU32);
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SymbolStackVariable(NonZeroU32);
 
 impl SymbolStackVariable {
     pub fn new(variable: u32) -> Option<SymbolStackVariable> {
@@ -218,13 +218,37 @@ impl TryFrom<u32> for SymbolStackVariable {
     }
 }
 
+impl Niche for SymbolStackVariable {
+    type Output = u32;
+
+    #[inline]
+    fn none() -> Self::Output {
+        0
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        *value == 0
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        value.as_u32()
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Self(unsafe { NonZeroU32::new_unchecked(value) })
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Scope stack variables
 
 /// Represents an unknown list of exported scopes.
 #[repr(transparent)]
-#[derive(Clone, Copy, Debug, Eq, Hash, Niche, Ord, PartialEq, PartialOrd)]
-pub struct ScopeStackVariable(#[niche] NonZeroU32);
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ScopeStackVariable(NonZeroU32);
 
 impl ScopeStackVariable {
     pub fn new(variable: u32) -> Option<ScopeStackVariable> {
@@ -289,6 +313,30 @@ impl TryFrom<u32> for ScopeStackVariable {
     }
 }
 
+impl Niche for ScopeStackVariable {
+    type Output = u32;
+
+    #[inline]
+    fn none() -> Self::Output {
+        0
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        *value == 0
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        value.as_u32()
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Self(unsafe { NonZeroU32::new_unchecked(value) })
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial symbol stacks
 
@@ -855,7 +903,7 @@ impl DisplayWithPartialPaths for PartialSymbolStack {
 /// A pattern that might match against a scope stack.  Consists of a (possibly empty) list of
 /// exported scopes, along with an optional scope stack variable.
 #[repr(C)]
-#[derive(Clone, Copy, Niche)]
+#[derive(Clone, Copy, Eq, Hash, Niche, PartialEq)]
 pub struct PartialScopeStack {
     #[niche]
     scopes: ReversibleList<Handle<Node>>,

From 296a72f81fa3384af8065c001052a99da13eb086 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Tue, 14 Mar 2023 11:26:47 +0100
Subject: [PATCH 08/12] Replace derived Niche implementation with explicit
 trait-friendly ones

---
 stack-graphs/src/arena.rs   | 154 +++++++++++++++++++++++++++++++++-
 stack-graphs/src/partial.rs | 159 +++++++++++++++++++++++++++++++++---
 2 files changed, 296 insertions(+), 17 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 613f6e474..a658732ae 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -43,6 +43,7 @@ use std::ops::IndexMut;
 use std::ops::Range;
 
 use bitvec::vec::BitVec;
+use controlled_option::ControlledOption;
 use controlled_option::Niche;
 
 use crate::utils::cmp_option;
@@ -546,12 +547,11 @@ impl<T> Default for HandleSet<T> {
 /// linked list implementation _should_ be cache-friendly, since the individual cells are allocated
 /// out of an arena.
 #[repr(C)]
-#[derive(Eq, Hash, Niche, PartialEq)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct List<T> {
     // The value of this handle will be EMPTY_LIST_HANDLE if the list is empty.  For an
     // Option<List<T>>, the value will be zero (via the Option<NonZero> optimization) if the list
     // is None.
-    #[niche]
     cells: Handle<ListCell<T>>,
 }
 
@@ -697,6 +697,53 @@ impl<T> Clone for List<T> {
 
 impl<T> Copy for List<T> {}
 
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheList<T> {
+    cells: ControlledOption<Handle<ListCell<T>>>,
+}
+
+impl<T> Niche for List<T> {
+    type Output = NicheList<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheList {
+            cells: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.cells.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheList {
+            cells: ControlledOption::from(value.cells),
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        List {
+            cells: value
+                .cells
+                .into_option()
+                .expect("Niche::from_some called on none value of ControlledOption<List<_>>"),
+        }
+    }
+}
+
+impl<T> Clone for NicheList<T> {
+    fn clone(&self) -> Self {
+        Self { cells: self.cells }
+    }
+}
+
+impl<T> Copy for NicheList<T> {}
+
 //-------------------------------------------------------------------------------------------------
 // Reversible arena-allocated list
 
@@ -708,9 +755,8 @@ impl<T> Copy for List<T> {}
 ///
 /// [`List`]: struct.List.html
 #[repr(C)]
-#[derive(Eq, Hash, Niche, PartialEq)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct ReversibleList<T> {
-    #[niche]
     cells: Handle<ReversibleListCell<T>>,
 }
 
@@ -970,6 +1016,52 @@ impl<T> Clone for ReversibleList<T> {
 
 impl<T> Copy for ReversibleList<T> {}
 
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheReversibleList<T> {
+    cells: ControlledOption<Handle<ReversibleListCell<T>>>,
+}
+
+impl<T> Niche for ReversibleList<T> {
+    type Output = NicheReversibleList<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheReversibleList {
+            cells: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.cells.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheReversibleList {
+            cells: ControlledOption::from(value.cells),
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        ReversibleList {
+            cells: value.cells.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<ReversibleList<_>>",
+            ),
+        }
+    }
+}
+
+impl<T> Clone for NicheReversibleList<T> {
+    fn clone(&self) -> Self {
+        Self { cells: self.cells }
+    }
+}
+
+impl<T> Copy for NicheReversibleList<T> {}
+
 //-------------------------------------------------------------------------------------------------
 // Arena-allocated deque
 
@@ -1265,3 +1357,57 @@ impl<T> Clone for Deque<T> {
 }
 
 impl<T> Copy for Deque<T> {}
+
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheDeque<T> {
+    list: ControlledOption<ReversibleList<T>>,
+    direction: DequeDirection,
+}
+
+impl<T> Niche for Deque<T> {
+    type Output = NicheDeque<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheDeque {
+            list: ControlledOption::none(),
+            direction: DequeDirection::Forwards,
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.list.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheDeque {
+            list: ControlledOption::from(value.list),
+            direction: value.direction,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Deque {
+            list: value
+                .list
+                .into_option()
+                .expect("Niche::from_some called on none value of ControlledOption<Deque<_>>"),
+            direction: value.direction,
+        }
+    }
+}
+
+impl<T> Clone for NicheDeque<T> {
+    fn clone(&self) -> Self {
+        Self {
+            list: self.list,
+            direction: self.direction,
+        }
+    }
+}
+
+impl<T> Copy for NicheDeque<T> {}
diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index 4d996e7b9..11e7c9746 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -36,6 +36,7 @@
 use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::fmt::Display;
+use std::hash::Hash;
 use std::num::NonZeroU32;
 
 use controlled_option::ControlledOption;
@@ -305,14 +306,6 @@ impl Into<u32> for ScopeStackVariable {
     }
 }
 
-impl TryFrom<u32> for ScopeStackVariable {
-    type Error = ();
-    fn try_from(value: u32) -> Result<ScopeStackVariable, ()> {
-        let value = NonZeroU32::new(value).ok_or(())?;
-        Ok(ScopeStackVariable(value))
-    }
-}
-
 impl Niche for ScopeStackVariable {
     type Output = u32;
 
@@ -337,12 +330,20 @@ impl Niche for ScopeStackVariable {
     }
 }
 
+impl TryFrom<u32> for ScopeStackVariable {
+    type Error = ();
+    fn try_from(value: u32) -> Result<ScopeStackVariable, ()> {
+        let value = NonZeroU32::new(value).ok_or(())?;
+        Ok(ScopeStackVariable(value))
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial symbol stacks
 
 /// A symbol with an unknown, but possibly empty, list of exported scopes attached to it.
 #[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialScopedSymbol {
     pub symbol: Handle<Symbol>,
     // Note that not having an attached scope list is _different_ than having an empty attached
@@ -490,9 +491,8 @@ impl DisplayWithPartialPaths for PartialScopedSymbol {
 /// A pattern that might match against a symbol stack.  Consists of a (possibly empty) list of
 /// partial scoped symbols, along with an optional symbol stack variable.
 #[repr(C)]
-#[derive(Clone, Copy, Niche)]
+#[derive(Clone, Copy)]
 pub struct PartialSymbolStack {
-    #[niche]
     symbols: ReversibleList<PartialScopedSymbol>,
     length: u32,
     variable: ControlledOption<SymbolStackVariable>,
@@ -897,15 +897,60 @@ impl DisplayWithPartialPaths for PartialSymbolStack {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialSymbolStack {
+    symbols: ControlledOption<ReversibleList<PartialScopedSymbol>>,
+    length: u32,
+    variable: ControlledOption<SymbolStackVariable>,
+}
+
+impl Niche for PartialSymbolStack {
+    type Output = NichePartialSymbolStack;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialSymbolStack {
+            symbols: ControlledOption::none(),
+            length: 0,
+            variable: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.symbols.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialSymbolStack {
+            symbols: ControlledOption::from(value.symbols),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialSymbolStack {
+            symbols: value.symbols.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialSymbolStack>",
+            ),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial scope stacks
 
 /// A pattern that might match against a scope stack.  Consists of a (possibly empty) list of
 /// exported scopes, along with an optional scope stack variable.
 #[repr(C)]
-#[derive(Clone, Copy, Eq, Hash, Niche, PartialEq)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialScopeStack {
-    #[niche]
     scopes: ReversibleList<Handle<Node>>,
     length: u32,
     variable: ControlledOption<ScopeStackVariable>,
@@ -1242,6 +1287,52 @@ impl DisplayWithPartialPaths for PartialScopeStack {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialScopeStack {
+    scopes: ControlledOption<ReversibleList<Handle<Node>>>,
+    length: u32,
+    variable: ControlledOption<ScopeStackVariable>,
+}
+
+impl Niche for PartialScopeStack {
+    type Output = NichePartialScopeStack;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialScopeStack {
+            scopes: ControlledOption::none(),
+            length: 0,
+            variable: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.scopes.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialScopeStack {
+            scopes: ControlledOption::from(value.scopes),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialScopeStack {
+            scopes: value.scopes.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialScopeStack>",
+            ),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial symbol bindings
 
@@ -1645,6 +1736,48 @@ impl DisplayWithPartialPaths for PartialPathEdgeList {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialPathEdgeList {
+    edges: ControlledOption<Deque<PartialPathEdge>>,
+    length: u32,
+}
+
+impl Niche for PartialPathEdgeList {
+    type Output = NichePartialPathEdgeList;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialPathEdgeList {
+            edges: ControlledOption::none(),
+            length: 0,
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.edges.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialPathEdgeList {
+            edges: ControlledOption::from(value.edges),
+            length: value.length,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialPathEdgeList {
+            edges: value.edges.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialPathEdgeList>",
+            ),
+            length: value.length,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial paths
 

From 1f2cb0a95519f2a8a7a597052bc6846c2f73b4b2 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Tue, 14 Mar 2023 11:49:36 +0100
Subject: [PATCH 09/12] Run arena tests against both implementations

---
 stack-graphs/tests/it/arena.rs | 301 +++++++++++++++++----------------
 1 file changed, 158 insertions(+), 143 deletions(-)

diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 6364deb7d..1e611f73d 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -30,6 +30,20 @@ fn can_allocate_in_arena() {
     assert_ne!(arena.get(hello2), arena.get(there));
 }
 
+#[test]
+fn can_allocate_in_interning_arena() {
+    let mut arena = HashArena::new();
+    let hello1 = arena.add("hello".to_string());
+    let hello2 = arena.add("hello".to_string());
+    let there = arena.add("there".to_string());
+    assert_eq!(hello1, hello2);
+    assert_ne!(hello1, there);
+    assert_ne!(hello2, there);
+    assert_eq!(arena.get(hello1), arena.get(hello2));
+    assert_ne!(arena.get(hello1), arena.get(there));
+    assert_ne!(arena.get(hello2), arena.get(there));
+}
+
 #[test]
 fn can_allocate_in_supplemental_arena() {
     let mut arena = VecArena::<u32>::new();
@@ -50,43 +64,48 @@ fn can_create_lists() {
     fn collect(list: &List<u32>, arena: &impl ListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
-
-    let mut arena = List::new_arena();
-    let mut list = List::empty();
-    assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
-    list.push_front(&mut arena, 1);
-    assert_eq!(collect(&list, &arena), vec![1]);
-    list.push_front(&mut arena, 2);
-    list.push_front(&mut arena, 3);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+    fn run(mut arena: impl ListArena<u32>) {
+        let mut list = List::empty();
+        assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
+        list.push_front(&mut arena, 1);
+        assert_eq!(collect(&list, &arena), vec![1]);
+        list.push_front(&mut arena, 2);
+        list.push_front(&mut arena, 3);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_lists() {
-    use std::cmp::Ordering;
-    let mut arena = List::new_arena();
-    let mut from_slice = |slice: &[u32]| {
-        let mut list = List::empty();
-        for element in slice.iter().rev() {
-            list.push_front(&mut arena, *element);
-        }
-        list
-    };
-    let list0 = from_slice(&[]);
-    let list1 = from_slice(&[1]);
-    let list2 = from_slice(&[2]);
-    let list12 = from_slice(&[1, 2]);
-    assert!(list0.equals(&arena, list0));
-    assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
-    assert!(!list0.equals(&arena, list1));
-    assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
-    assert!(list1.equals(&arena, list1));
-    assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
-    assert!(!list1.equals(&arena, list2));
-    assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
-    assert!(list2.equals(&arena, list2));
-    assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
-    assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+    fn run(mut arena: impl ListArena<u32>) {
+        use std::cmp::Ordering;
+        let mut from_slice = |slice: &[u32]| {
+            let mut list = List::empty();
+            for element in slice.iter().rev() {
+                list.push_front(&mut arena, *element);
+            }
+            list
+        };
+        let list0 = from_slice(&[]);
+        let list1 = from_slice(&[1]);
+        let list2 = from_slice(&[2]);
+        let list12 = from_slice(&[1, 2]);
+        assert!(list0.equals(&arena, list0));
+        assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
+        assert!(!list0.equals(&arena, list1));
+        assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
+        assert!(list1.equals(&arena, list1));
+        assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
+        assert!(!list1.equals(&arena, list2));
+        assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
+        assert!(list2.equals(&arena, list2));
+        assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
+        assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
@@ -94,56 +113,61 @@ fn can_create_reversible_lists() {
     fn collect(list: &ReversibleList<u32>, arena: &impl ReversibleListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
-
-    let mut arena = ReversibleList::new_arena();
-    let mut list = ReversibleList::empty();
-    assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
-    list.push_front(&mut arena, 1);
-    assert_eq!(collect(&list, &arena), vec![1]);
-    list.push_front(&mut arena, 2);
-    list.push_front(&mut arena, 3);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
-    list.reverse(&mut arena);
-    assert_eq!(collect(&list, &arena), vec![1, 2, 3]);
-    list.push_front(&mut arena, 4);
-    list.push_front(&mut arena, 5);
-    assert_eq!(collect(&list, &arena), vec![5, 4, 1, 2, 3]);
-    list.reverse(&mut arena);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1, 4, 5]);
-    // Verify that we stash away the re-reversal so that we don't have to recompute it.
-    assert!(list.have_reversal(&arena));
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut list = ReversibleList::empty();
+        assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
+        list.push_front(&mut arena, 1);
+        assert_eq!(collect(&list, &arena), vec![1]);
+        list.push_front(&mut arena, 2);
+        list.push_front(&mut arena, 3);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+        list.reverse(&mut arena);
+        assert_eq!(collect(&list, &arena), vec![1, 2, 3]);
+        list.push_front(&mut arena, 4);
+        list.push_front(&mut arena, 5);
+        assert_eq!(collect(&list, &arena), vec![5, 4, 1, 2, 3]);
+        list.reverse(&mut arena);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1, 4, 5]);
+        // Verify that we stash away the re-reversal so that we don't have to recompute it.
+        assert!(list.have_reversal(&arena));
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_reversible_lists() {
     use std::cmp::Ordering;
-    let mut arena = ReversibleList::new_arena();
-    let mut from_slice = |slice: &[u32]| {
-        let mut list = ReversibleList::empty();
-        for element in slice.iter().rev() {
-            list.push_front(&mut arena, *element);
-        }
-        list
-    };
-    let list0 = from_slice(&[]);
-    let list1 = from_slice(&[1]);
-    let list2 = from_slice(&[2]);
-    let list12 = from_slice(&[1, 2]);
-    assert!(list0.equals(&arena, list0));
-    assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
-    assert!(!list0.equals(&arena, list1));
-    assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
-    assert!(list1.equals(&arena, list1));
-    assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
-    assert!(!list1.equals(&arena, list2));
-    assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
-    assert!(list2.equals(&arena, list2));
-    assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
-    assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
-    let mut list21 = list12;
-    list21.reverse(&mut arena);
-    assert_eq!(list2.cmp(&arena, list21), Ordering::Less);
-    assert_eq!(list1.cmp(&arena, list21), Ordering::Less);
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut from_slice = |slice: &[u32]| {
+            let mut list = ReversibleList::empty();
+            for element in slice.iter().rev() {
+                list.push_front(&mut arena, *element);
+            }
+            list
+        };
+        let list0 = from_slice(&[]);
+        let list1 = from_slice(&[1]);
+        let list2 = from_slice(&[2]);
+        let list12 = from_slice(&[1, 2]);
+        assert!(list0.equals(&arena, list0));
+        assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
+        assert!(!list0.equals(&arena, list1));
+        assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
+        assert!(list1.equals(&arena, list1));
+        assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
+        assert!(!list1.equals(&arena, list2));
+        assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
+        assert!(list2.equals(&arena, list2));
+        assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
+        assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+        let mut list21 = list12;
+        list21.reverse(&mut arena);
+        assert_eq!(list2.cmp(&arena, list21), Ordering::Less);
+        assert_eq!(list1.cmp(&arena, list21), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
@@ -157,39 +181,40 @@ fn can_create_deques() {
     fn collect_rev(deque: &Deque<u32>, arena: &mut impl DequeArena<u32>) -> Vec<u32> {
         deque.iter_reversed(arena).copied().collect()
     }
-
-    let mut arena = Deque::new_arena();
-    let mut deque = Deque::empty();
-    assert_eq!(collect(&deque, &mut arena), vec![] as Vec<u32>);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![] as Vec<u32>);
-    deque.push_front(&mut arena, 1);
-    assert_eq!(collect(&deque, &mut arena), vec![1]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![1]);
-    deque.push_front(&mut arena, 2);
-    deque.push_front(&mut arena, 3);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![1, 2, 3]);
-    deque.push_back(&mut arena, 4);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![4, 1, 2, 3]);
-    deque.push_back(&mut arena, 5);
-    deque.push_back(&mut arena, 6);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4, 5, 6]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![6, 5, 4, 1, 2, 3]);
-    deque.push_front(&mut arena, 7);
-    deque.push_front(&mut arena, 8);
-    assert_eq!(collect(&deque, &mut arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
-    assert_eq!(collect_reused(&deque, &arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
-    assert_eq!(
-        collect_rev(&deque, &mut arena),
-        vec![6, 5, 4, 1, 2, 3, 7, 8]
-    );
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut deque = Deque::empty();
+        assert_eq!(collect(&deque, &mut arena), vec![] as Vec<u32>);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![] as Vec<u32>);
+        deque.push_front(&mut arena, 1);
+        assert_eq!(collect(&deque, &mut arena), vec![1]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![1]);
+        deque.push_front(&mut arena, 2);
+        deque.push_front(&mut arena, 3);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![1, 2, 3]);
+        deque.push_back(&mut arena, 4);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![4, 1, 2, 3]);
+        deque.push_back(&mut arena, 5);
+        deque.push_back(&mut arena, 6);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4, 5, 6]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![6, 5, 4, 1, 2, 3]);
+        deque.push_front(&mut arena, 7);
+        deque.push_front(&mut arena, 8);
+        assert_eq!(collect(&deque, &mut arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
+        assert_eq!(collect_reused(&deque, &arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
+        assert_eq!(
+            collect_rev(&deque, &mut arena),
+            vec![6, 5, 4, 1, 2, 3, 7, 8]
+        );
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_deques() {
     use std::cmp::Ordering;
-    let mut arena = Deque::new_arena();
     // Build up deques in both directions so that our comparisons have to test the "reverse if
     // needed" logic.
     fn from_slice_forwards(slice: &[u32], arena: &mut impl DequeArena<u32>) -> Deque<u32> {
@@ -206,42 +231,32 @@ fn can_compare_deques() {
         }
         deque
     }
-    let deque0 = from_slice_forwards(&[], &mut arena);
-    let mut deque1 = from_slice_backwards(&[1], &mut arena);
-    let deque2 = from_slice_forwards(&[2], &mut arena);
-    let mut deque10 = from_slice_backwards(&[1, 0], &mut arena);
-    let deque12 = from_slice_backwards(&[1, 2], &mut arena);
-    assert!(deque0.equals(&mut arena, deque0));
-    assert_eq!(deque0.cmp(&mut arena, deque0), Ordering::Equal);
-    assert!(!deque0.equals(&mut arena, deque1));
-    assert_eq!(deque0.cmp(&mut arena, deque1), Ordering::Less);
-    assert!(deque1.equals(&mut arena, deque1));
-    assert_eq!(deque1.cmp(&mut arena, deque1), Ordering::Equal);
-    assert!(!deque1.equals(&mut arena, deque2));
-    assert_eq!(deque1.cmp(&mut arena, deque2), Ordering::Less);
-    assert!(deque2.equals(&mut arena, deque2));
-    assert_eq!(deque2.cmp(&mut arena, deque12), Ordering::Greater);
-    assert_eq!(deque1.cmp(&mut arena, deque12), Ordering::Less);
-
-    // We should get the same result regardless of which direction the deques are pointing.
-    deque1.ensure_forwards(&mut arena);
-    deque10.ensure_forwards(&mut arena);
-    assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
-    deque1.ensure_backwards(&mut arena);
-    deque10.ensure_backwards(&mut arena);
-    assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
-}
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let deque0 = from_slice_forwards(&[], &mut arena);
+        let mut deque1 = from_slice_backwards(&[1], &mut arena);
+        let deque2 = from_slice_forwards(&[2], &mut arena);
+        let mut deque10 = from_slice_backwards(&[1, 0], &mut arena);
+        let deque12 = from_slice_backwards(&[1, 2], &mut arena);
+        assert!(deque0.equals(&mut arena, deque0));
+        assert_eq!(deque0.cmp(&mut arena, deque0), Ordering::Equal);
+        assert!(!deque0.equals(&mut arena, deque1));
+        assert_eq!(deque0.cmp(&mut arena, deque1), Ordering::Less);
+        assert!(deque1.equals(&mut arena, deque1));
+        assert_eq!(deque1.cmp(&mut arena, deque1), Ordering::Equal);
+        assert!(!deque1.equals(&mut arena, deque2));
+        assert_eq!(deque1.cmp(&mut arena, deque2), Ordering::Less);
+        assert!(deque2.equals(&mut arena, deque2));
+        assert_eq!(deque2.cmp(&mut arena, deque12), Ordering::Greater);
+        assert_eq!(deque1.cmp(&mut arena, deque12), Ordering::Less);
 
-#[test]
-fn can_allocate_in_interning_arena() {
-    let mut arena = HashArena::new();
-    let hello1 = arena.add("hello".to_string());
-    let hello2 = arena.add("hello".to_string());
-    let there = arena.add("there".to_string());
-    assert_eq!(hello1, hello2);
-    assert_ne!(hello1, there);
-    assert_ne!(hello2, there);
-    assert_eq!(arena.get(hello1), arena.get(hello2));
-    assert_ne!(arena.get(hello1), arena.get(there));
-    assert_ne!(arena.get(hello2), arena.get(there));
+        // We should get the same result regardless of which direction the deques are pointing.
+        deque1.ensure_forwards(&mut arena);
+        deque10.ensure_forwards(&mut arena);
+        assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
+        deque1.ensure_backwards(&mut arena);
+        deque10.ensure_backwards(&mut arena);
+        assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }

From b4b84ea3bc36f6b33398d2ae6cf07753e3c6652a Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Tue, 14 Mar 2023 12:00:28 +0100
Subject: [PATCH 10/12] Switch to HashArena for PartialPaths

---
 stack-graphs/src/partial.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index 11e7c9746..790daedd6 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -47,8 +47,8 @@ use smallvec::SmallVec;
 use crate::arena::Deque;
 use crate::arena::DequeCell;
 use crate::arena::Handle;
+use crate::arena::HashArena;
 use crate::arena::ReversibleList;
-use crate::arena::VecArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::graph::Edge;
@@ -2853,17 +2853,17 @@ struct Join {
 /// Manages the state of a collection of partial paths built up as part of the partial-path-finding
 /// algorithm or path-stitching algorithm.
 pub struct PartialPaths {
-    pub(crate) partial_symbol_stacks: VecArena<DequeCell<PartialScopedSymbol>>,
-    pub(crate) partial_scope_stacks: VecArena<DequeCell<Handle<Node>>>,
-    pub(crate) partial_path_edges: VecArena<DequeCell<PartialPathEdge>>,
+    pub(crate) partial_symbol_stacks: HashArena<DequeCell<PartialScopedSymbol>>,
+    pub(crate) partial_scope_stacks: HashArena<DequeCell<Handle<Node>>>,
+    pub(crate) partial_path_edges: HashArena<DequeCell<PartialPathEdge>>,
 }
 
 impl PartialPaths {
     pub fn new() -> PartialPaths {
         PartialPaths {
-            partial_symbol_stacks: VecArena::new(),
-            partial_scope_stacks: VecArena::new(),
-            partial_path_edges: VecArena::new(),
+            partial_symbol_stacks: HashArena::new(),
+            partial_scope_stacks: HashArena::new(),
+            partial_path_edges: HashArena::new(),
         }
     }
 }

From 5f9f4ae10fd1f68f182a220db50b20667497978c Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Tue, 14 Mar 2023 12:02:06 +0100
Subject: [PATCH 11/12] Use HashArena for symbol stack keys

---
 stack-graphs/src/stitching.rs | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/stack-graphs/src/stitching.rs b/stack-graphs/src/stitching.rs
index 4865a69db..7987f7abc 100644
--- a/stack-graphs/src/stitching.rs
+++ b/stack-graphs/src/stitching.rs
@@ -35,7 +35,6 @@
 //! [`Database`]: struct.Database.html
 //! [`PathStitcher`]: struct.PathStitcher.html
 
-use std::collections::HashMap;
 use std::collections::VecDeque;
 #[cfg(feature = "copious-debugging")]
 use std::fmt::Display;
@@ -44,6 +43,7 @@ use std::ops::Index;
 use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::arena::HandleSet;
+use crate::arena::HashArena;
 use crate::arena::List;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
@@ -76,8 +76,7 @@ use crate::CancellationFlag;
 pub struct Database {
     pub(crate) partial_paths: VecArena<PartialPath>,
     pub(crate) local_nodes: HandleSet<Node>,
-    symbol_stack_keys: VecArena<ListCell<Handle<Symbol>>>,
-    symbol_stack_key_cache: HashMap<SymbolStackCacheKey, SymbolStackKeyHandle>,
+    symbol_stack_keys: HashArena<ListCell<Handle<Symbol>>>,
     paths_by_start_node: SupplementalArena<Node, Vec<Handle<PartialPath>>>,
     root_paths_by_precondition: SupplementalArena<SymbolStackKeyCell, Vec<Handle<PartialPath>>>,
 }
@@ -88,8 +87,7 @@ impl Database {
         Database {
             partial_paths: VecArena::new(),
             local_nodes: HandleSet::new(),
-            symbol_stack_keys: VecArena::new(),
-            symbol_stack_key_cache: HashMap::new(),
+            symbol_stack_keys: HashArena::new(),
             paths_by_start_node: SupplementalArena::new(),
             root_paths_by_precondition: SupplementalArena::new(),
         }
@@ -362,18 +360,7 @@ impl SymbolStackKey {
 
     /// Pushes a new symbol onto the back of this symbol stack key.
     fn push_back(&mut self, db: &mut Database, symbol: Handle<Symbol>) {
-        let cache_key = SymbolStackCacheKey {
-            head: symbol,
-            tail: self.back_handle(),
-        };
-        if let Some(handle) = db.symbol_stack_key_cache.get(&cache_key) {
-            self.symbols = List::from_handle(*handle);
-            return;
-        }
-        // push_front because we store the key's symbols in reverse order.
         self.symbols.push_front(&mut db.symbol_stack_keys, symbol);
-        let handle = self.back_handle();
-        db.symbol_stack_key_cache.insert(cache_key, handle);
     }
 
     /// Pops a symbol from the back of this symbol stack key.

From 1caa5ee2d40d4a20bcde87f81a70d880068f39b5 Mon Sep 17 00:00:00 2001
From: Hendrik van Antwerpen <hendrikvanantwerpen@github.com>
Date: Fri, 17 Mar 2023 15:07:58 +0100
Subject: [PATCH 12/12] Use handle equality

---
 stack-graphs/src/arena.rs   | 20 ++++++++++++++
 stack-graphs/src/partial.rs | 52 +++++++++++--------------------------
 2 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index a658732ae..383716e46 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -204,6 +204,10 @@ pub trait Arena<T> {
 
     /// Returns the number of instances stored in this arena.
     fn len(&self) -> usize;
+
+    /// Returns whether the values associated with the arena are equal, if this can be determined from the
+    /// handles alone. Otherwise, no value is returned.
+    fn try_equals(&self, lhs: Handle<T>, rhs: Handle<T>) -> Option<bool>;
 }
 
 /// Manages the life cycle of instances of type `T`.  You can allocate new instances of `T` from
@@ -261,6 +265,11 @@ impl<T> Arena<T> for VecArena<T> {
     fn len(&self) -> usize {
         self.items.len()
     }
+
+    #[inline]
+    fn try_equals(&self, _lhs: Handle<T>, _rhs: Handle<T>) -> Option<bool> {
+        None
+    }
 }
 
 /// An interning arena allocation.  Equal handles means equal elements.
@@ -320,6 +329,11 @@ where
     fn len(&self) -> usize {
         self.arena.len()
     }
+
+    #[inline]
+    fn try_equals(&self, lhs: Handle<T>, rhs: Handle<T>) -> Option<bool> {
+        Some(lhs == rhs)
+    }
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -672,6 +686,9 @@ where
     T: Eq,
 {
     pub fn equals(self, arena: &impl ListArena<T>, other: List<T>) -> bool {
+        if let Some(equals) = arena.try_equals(self.cells, other.cells) {
+            return equals;
+        }
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -987,6 +1004,9 @@ where
     T: Eq,
 {
     pub fn equals(self, arena: &impl ReversibleListArena<T>, other: ReversibleList<T>) -> bool {
+        if let Some(equals) = arena.try_equals(self.cells, other.cells) {
+            return equals;
+        }
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index 790daedd6..b6ccb0356 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -491,7 +491,7 @@ impl DisplayWithPartialPaths for PartialScopedSymbol {
 /// A pattern that might match against a symbol stack.  Consists of a (possibly empty) list of
 /// partial scoped symbols, along with an optional symbol stack variable.
 #[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialSymbolStack {
     symbols: ReversibleList<PartialScopedSymbol>,
     length: u32,
@@ -791,24 +791,13 @@ impl PartialSymbolStack {
         unreachable!();
     }
 
-    pub fn equals(mut self, partials: &mut PartialPaths, mut other: PartialSymbolStack) -> bool {
-        while let Some(self_symbol) = self.pop_front(partials) {
-            if let Some(other_symbol) = other.pop_front(partials) {
-                if !self_symbol.equals(partials, &other_symbol) {
-                    return false;
-                }
-            } else {
-                return false;
-            }
-        }
-        if !other.symbols.is_empty() {
-            return false;
-        }
-        equals_option(
-            self.variable.into_option(),
-            other.variable.into_option(),
-            |a, b| a == b,
-        )
+    pub fn equals(self, _partials: &mut PartialPaths, other: PartialSymbolStack) -> bool {
+        self.symbols == other.symbols
+            && equals_option(
+                self.variable.into_option(),
+                other.variable.into_option(),
+                |a, b| a == b,
+            )
     }
 
     pub fn cmp(
@@ -1204,11 +1193,8 @@ impl PartialScopeStack {
         self.variable.into_option()
     }
 
-    pub fn equals(self, partials: &mut PartialPaths, other: PartialScopeStack) -> bool {
-        self.scopes
-            .equals_with(&mut partials.partial_scope_stacks, other.scopes, |a, b| {
-                *a == *b
-            })
+    pub fn equals(self, _partials: &mut PartialPaths, other: PartialScopeStack) -> bool {
+        self.scopes == other.scopes
             && equals_option(
                 self.variable.into_option(),
                 other.variable.into_option(),
@@ -1852,21 +1838,13 @@ impl PartialPath {
         self.edges.shadows(partials, other.edges)
     }
 
-    pub fn equals(&self, partials: &mut PartialPaths, other: &PartialPath) -> bool {
+    pub fn equals(&self, _partials: &mut PartialPaths, other: &PartialPath) -> bool {
         self.start_node == other.start_node
             && self.end_node == other.end_node
-            && self
-                .symbol_stack_precondition
-                .equals(partials, other.symbol_stack_precondition)
-            && self
-                .symbol_stack_postcondition
-                .equals(partials, other.symbol_stack_postcondition)
-            && self
-                .scope_stack_precondition
-                .equals(partials, other.scope_stack_precondition)
-            && self
-                .scope_stack_postcondition
-                .equals(partials, other.scope_stack_postcondition)
+            && self.symbol_stack_precondition == other.symbol_stack_precondition
+            && self.symbol_stack_postcondition == other.symbol_stack_postcondition
+            && self.scope_stack_precondition == other.scope_stack_precondition
+            && self.scope_stack_postcondition == other.scope_stack_postcondition
     }
 
     pub fn cmp(