Add GraphEdges instead of () and support file filtering

Author: Hendrik van Antwerpen

stack-graphs/src/partial.rs

@@ -56,6 +56,7 @@ use crate::graph::StackGraph;
 use crate::graph::Symbol;
 use crate::paths::Extend;
 use crate::paths::PathResolutionError;
+use crate::stitching::GraphEdges;
 use crate::utils::cmp_option;
 use crate::utils::equals_option;
 use crate::CancellationError;
@@ -2549,7 +2550,7 @@ impl PartialPaths {
                 copious_debugging!("    * visit");
                 visit(graph, self, path);
             } else if !path_cycle_detector
-                .is_cyclic(graph, self, &(), &mut edges)
+                .is_cyclic(graph, self, &GraphEdges(Some(file)), &mut edges)
                 .expect("cyclic test failed when finding partial paths")
                 .is_empty()
             {
@@ -2608,7 +2609,7 @@ impl PartialPaths {
                 visit(graph, self, path.clone());
             }
             if !path_cycle_detector
-                .is_cyclic(graph, &mut partials, &(), &mut edges)
+                .is_cyclic(graph, &mut partials, &GraphEdges(None), &mut edges)
                 .expect("cyclic test failed when finding complete paths")
                 .into_iter()
                 .all(|c| c == Cyclicity::StrengthensPrecondition)

stack-graphs/src/stitching.rs

@@ -51,6 +51,7 @@ use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
+use crate::graph::File;
 use crate::graph::Node;
 use crate::graph::StackGraph;
 use crate::graph::Symbol;
@@ -162,18 +163,6 @@ where
     fn get_appendable<'a>(&'a self, handle: &'a H) -> &'a A;
 }
 
-impl ToAppendable<Handle<PartialPath>, PartialPath> for Database {
-    fn get_appendable<'a>(&'a self, handle: &'a Handle<PartialPath>) -> &'a PartialPath {
-        &self[*handle]
-    }
-}
-
-impl<A: Appendable + Clone> ToAppendable<A, A> for () {
-    fn get_appendable<'a>(&'a self, value: &'a A) -> &'a A {
-        value
-    }
-}
-
 //-------------------------------------------------------------------------------------------------
 // Candidates
 
@@ -188,7 +177,19 @@ pub trait Candidates<H> {
         R: std::iter::Extend<H>;
 }
 
-impl Candidates<Edge> for () {
+//-------------------------------------------------------------------------------------------------
+// FileEdges
+
+/// Acts as a database of the edges in the graph.
+pub struct GraphEdges(pub Option<Handle<File>>);
+
+impl ToAppendable<Edge, Edge> for GraphEdges {
+    fn get_appendable<'a>(&'a self, value: &'a Edge) -> &'a Edge {
+        value
+    }
+}
+
+impl Candidates<Edge> for GraphEdges {
     fn find_candidates<R>(
         &mut self,
         graph: &StackGraph,
@@ -198,7 +199,11 @@ impl Candidates<Edge> for () {
     ) where
         R: std::iter::Extend<Edge>,
     {
-        result.extend(graph.outgoing_edges(path.end_node));
+        result.extend(
+            graph
+                .outgoing_edges(path.end_node)
+                .filter(|e| self.0.map_or(true, |file| graph[e.sink].is_in_file(file))),
+        );
     }
 }
 
@@ -469,6 +474,12 @@ impl std::ops::Index<Handle<PartialPath>> for Database {
     }
 }
 
+impl ToAppendable<Handle<PartialPath>, PartialPath> for Database {
+    fn get_appendable<'a>(&'a self, handle: &'a Handle<PartialPath>) -> &'a PartialPath {
+        &self[*handle]
+    }
+}
+
 impl Candidates<Handle<PartialPath>> for Database {
     fn find_candidates<R>(
         &mut self,

stack-graphs/tests/it/cycles.rs

@@ -14,6 +14,7 @@ use stack_graphs::partial::Cyclicity;
 use stack_graphs::partial::PartialPath;
 use stack_graphs::partial::PartialPaths;
 use stack_graphs::stitching::Database;
+use stack_graphs::stitching::GraphEdges;
 use stack_graphs::CancelAfterDuration;
 use std::time::Duration;
 
@@ -169,7 +170,7 @@ fn finding_simple_identity_cycle_is_detected() {
     {
         let mut edges = Appendables::new();
         let mut cd = AppendingCycleDetector::new();
-        let ctx = &mut ();
+        let db = &GraphEdges(None);
 
         for edge in &[
             edge(r, foo_ref, 0),
@@ -178,15 +179,14 @@ fn finding_simple_identity_cycle_is_detected() {
         ] {
             cd.append(&mut edges, *edge);
             assert!(cd
-                .is_cyclic(&graph, &mut partials, ctx, &mut edges)
+                .is_cyclic(&graph, &mut partials, db, &mut edges)
                 .unwrap()
                 .is_empty());
         }
         cd.append(&mut edges, edge(foo_def, r, 0));
         assert_eq!(
             enum_set![Cyclicity::StrengthensPostcondition],
-            cd.is_cyclic(&graph, &mut partials, ctx, &mut edges)
-                .unwrap()
+            cd.is_cyclic(&graph, &mut partials, db, &mut edges).unwrap()
         );
     }
 
@@ -259,7 +259,7 @@ fn finding_composite_identity_cycle_is_detected() {
     {
         let mut edges = Appendables::new();
         let mut cd = AppendingCycleDetector::new();
-        let ctx = &mut ();
+        let db = &GraphEdges(None);
         for edge in &[
             edge(r, s, 0),
             edge(r, s, 0),
@@ -271,15 +271,14 @@ fn finding_composite_identity_cycle_is_detected() {
         ] {
             cd.append(&mut edges, *edge);
             assert!(cd
-                .is_cyclic(&graph, &mut partials, ctx, &mut edges)
+                .is_cyclic(&graph, &mut partials, db, &mut edges)
                 .unwrap()
                 .is_empty());
         }
         cd.append(&mut edges, edge(bar_ref, s, 0));
         assert_eq!(
             enum_set![Cyclicity::StrengthensPostcondition],
-            cd.is_cyclic(&graph, &mut partials, ctx, &mut edges)
-                .unwrap()
+            cd.is_cyclic(&graph, &mut partials, db, &mut edges).unwrap()
         );
     }