Promote Appendable::Ctx to proper type parameter

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -32,6 +32,7 @@
 use enumset::EnumSet;
 use smallvec::SmallVec;
 use std::collections::HashMap;
+use std::marker::PhantomData;
 
 use crate::arena::Handle;
 use crate::arena::List;
@@ -129,31 +130,42 @@ where
 // ----------------------------------------------------------------------------
 // Cycle detector
 
-pub trait Appendable {
-    type Ctx;
-
+pub trait Appendable<Ctx> {
     fn append_to(
         &self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
-        ctx: &mut Self::Ctx,
+        ctx: &mut Ctx,
         path: &mut PartialPath,
     ) -> Result<(), PathResolutionError>;
-    fn start_node(&self, ctx: &mut Self::Ctx) -> Handle<Node>;
-    fn end_node(&self, ctx: &mut Self::Ctx) -> Handle<Node>;
+    fn start_node(&self, ctx: &mut Ctx) -> Handle<Node>;
+    fn end_node(&self, ctx: &mut Ctx) -> Handle<Node>;
 }
 
-#[derive(Clone)]
-pub struct AppendingCycleDetector<A> {
+pub struct AppendingCycleDetector<Ctx, A>
+where
+    A: Appendable<Ctx>,
+{
     appendages: List<A>,
+    ctx: PhantomData<Ctx>,
+}
+
+impl<Ctx, A: Appendable<Ctx>> Clone for AppendingCycleDetector<Ctx, A> {
+    fn clone(&self) -> Self {
+        Self {
+            appendages: self.appendages.clone(),
+            ctx: PhantomData::default(),
+        }
+    }
 }
 
 pub type Appendables<A> = ListArena<A>;
 
-impl<A: Appendable + Clone> AppendingCycleDetector<A> {
+impl<Ctx, A: Appendable<Ctx> + Clone> AppendingCycleDetector<Ctx, A> {
     pub fn new() -> Self {
         Self {
             appendages: List::empty(),
+            ctx: PhantomData::default(),
         }
     }
 
@@ -173,7 +185,7 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
         &self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
-        ctx: &mut A::Ctx,
+        ctx: &mut Ctx,
         appendables: &mut Appendables<A>,
     ) -> Result<EnumSet<Cyclicity>, PathResolutionError> {
         let mut cycles = EnumSet::new();
@@ -223,9 +235,7 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
     }
 }
 
-impl Appendable for Edge {
-    type Ctx = ();
-
+impl Appendable<()> for Edge {
     fn append_to(
         &self,
         graph: &StackGraph,
@@ -245,9 +255,7 @@ impl Appendable for Edge {
     }
 }
 
-impl Appendable for OwnedOrDatabasePath {
-    type Ctx = Database;
-
+impl Appendable<Database> for OwnedOrDatabasePath {
     fn append_to(
         &self,
         graph: &StackGraph,

stack-graphs/src/partial.rs

@@ -2225,13 +2225,13 @@ impl PartialPath {
     /// as a parameter, instead of building it up ourselves, so that you have control over which
     /// particular collection type to use, and so that you can reuse result collections across
     /// multiple calls.
-    fn extend<R: Extend<(PartialPath, AppendingCycleDetector<Edge>)>>(
+    fn extend<R: Extend<(PartialPath, AppendingCycleDetector<(), Edge>)>>(
         &self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
         file: Option<Handle<File>>,
         edges: &mut Appendables<Edge>,
-        path_cycle_detector: AppendingCycleDetector<Edge>,
+        path_cycle_detector: AppendingCycleDetector<(), Edge>,
         result: &mut R,
     ) {
         let extensions = graph.outgoing_edges(self.end_node);

stack-graphs/src/stitching.rs

@@ -463,12 +463,15 @@ impl<'a> Display for DisplaySymbolStackKey<'a> {
 /// [`find_all_complete_partial_paths`]: #method.find_all_complete_partial_paths
 pub struct ForwardPartialPathStitcher {
     candidate_partial_paths: Vec<Handle<PartialPath>>,
-    queue: VecDeque<(PartialPath, AppendingCycleDetector<OwnedOrDatabasePath>)>,
+    queue: VecDeque<(
+        PartialPath,
+        AppendingCycleDetector<Database, OwnedOrDatabasePath>,
+    )>,
     // next_iteration is a tuple of queues instead of an queue of tuples so that the path queue
     // can be cheaply exposed through the C API as a continuous memory block
     next_iteration: (
         VecDeque<PartialPath>,
-        VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
+        VecDeque<AppendingCycleDetector<Database, OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
     similar_path_detector: Option<SimilarPathDetector<PartialPath>>,
@@ -590,7 +593,7 @@ impl ForwardPartialPathStitcher {
         partials: &mut PartialPaths,
         db: &mut Database,
         partial_path: &PartialPath,
-        cycle_detector: AppendingCycleDetector<OwnedOrDatabasePath>,
+        cycle_detector: AppendingCycleDetector<Database, OwnedOrDatabasePath>,
     ) -> usize {
         self.candidate_partial_paths.clear();
         if graph[partial_path.end_node].is_root() {

stack-graphs/tests/it/cycles.rs

@@ -224,7 +224,7 @@ fn stitching_simple_identity_cycle_is_detected() {
     // test partial path cycle detector
     {
         let mut paths = Appendables::new();
-        let mut cd: AppendingCycleDetector<OwnedOrDatabasePath> =
+        let mut cd: AppendingCycleDetector<Database, OwnedOrDatabasePath> =
             AppendingCycleDetector::from(&mut paths, p0.into());
         cd.append(&mut paths, p1.into());
         assert_eq!(
@@ -320,7 +320,7 @@ fn stitching_composite_identity_cycle_is_detected() {
     // test joining cycle detector
     {
         let mut paths = Appendables::new();
-        let mut cd: AppendingCycleDetector<OwnedOrDatabasePath> =
+        let mut cd: AppendingCycleDetector<Database, OwnedOrDatabasePath> =
             AppendingCycleDetector::from(&mut paths, p0.into());
         cd.append(&mut paths, p1.into());
         assert_eq!(