Use partial paths + stitching for tests and visualization

Author: Hendrik van Antwerpen

stack-graphs/src/assert.rs

@@ -15,8 +15,10 @@ use crate::graph::File;
 use crate::graph::Node;
 use crate::graph::StackGraph;
 use crate::graph::Symbol;
-use crate::paths::Path;
-use crate::paths::Paths;
+use crate::partial::PartialPath;
+use crate::partial::PartialPaths;
+use crate::stitching::Database;
+use crate::stitching::ForwardPartialPathStitcher;
 use crate::CancellationError;
 use crate::CancellationFlag;
 
@@ -100,7 +102,7 @@ pub enum AssertionError {
         source: AssertionSource,
         references: Vec<Handle<Node>>,
         missing_targets: Vec<AssertionTarget>,
-        unexpected_paths: Vec<Path>,
+        unexpected_paths: Vec<PartialPath>,
     },
     IncorrectDefinitions {
         source: AssertionSource,
@@ -126,12 +128,13 @@ impl Assertion {
     pub fn run(
         &self,
         graph: &StackGraph,
-        paths: &mut Paths,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         cancellation_flag: &dyn CancellationFlag,
     ) -> Result<(), AssertionError> {
         match self {
             Self::Defined { source, targets } => {
-                self.run_defined(graph, paths, source, targets, cancellation_flag)
+                self.run_defined(graph, partials, db, source, targets, cancellation_flag)
             }
             Self::Defines { source, symbols } => self.run_defines(graph, source, symbols),
             Self::Refers { source, symbols } => self.run_refers(graph, source, symbols),
@@ -141,7 +144,8 @@ impl Assertion {
     fn run_defined(
         &self,
         graph: &StackGraph,
-        paths: &mut Paths,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         source: &AssertionSource,
         expected_targets: &Vec<AssertionTarget>,
         cancellation_flag: &dyn CancellationFlag,
@@ -154,12 +158,24 @@ impl Assertion {
         }
 
         let mut actual_paths = Vec::new();
-        paths.find_all_paths(graph, references.clone(), cancellation_flag, |g, _ps, p| {
-            if p.is_complete(g) {
-                actual_paths.push(p);
+        for reference in &references {
+            let reference_paths = ForwardPartialPathStitcher::find_all_complete_partial_paths(
+                graph,
+                partials,
+                db,
+                vec![*reference],
+                cancellation_flag,
+            )?;
+            for reference_path in &reference_paths {
+                if reference_paths
+                    .iter()
+                    .all(|other| !other.shadows(partials, reference_path))
+                {
+                    actual_paths.push(reference_path.clone());
+                }
             }
-        })?;
-        paths.remove_shadowed_paths(&mut actual_paths, cancellation_flag)?;
+        }
+
         let missing_targets = expected_targets
             .iter()
             .filter(|t| {

stack-graphs/src/json.rs

@@ -113,7 +113,7 @@ where
     }
 }
 
-/// Struct that ensures the implications of exclusions.
+/// Filter implementation that enforces all implications of another filter.
 /// For example, that nodes frome excluded files are not included, etc.
 struct ImplicationFilter<'a>(&'a dyn Filter);
 
@@ -152,18 +152,25 @@ impl Filter for ImplicationFilter<'_> {
         paths: &PartialPaths,
         path: &PartialPath,
     ) -> bool {
-        path.edges
+        let super_ok = self.0.include_partial_path(graph, paths, path);
+        if !super_ok {
+            return false;
+        }
+        let all_included_edges = path
+            .edges
             .iter_unordered(paths)
             .map(|e| graph.node_for_id(e.source_node_id).unwrap())
             .chain(std::iter::once(path.end_node))
             .tuple_windows()
-            .all(|(source, sink)| self.include_edge(graph, &source, &sink))
-            && self.0.include_partial_path(graph, paths, path)
+            .all(|(source, sink)| self.include_edge(graph, &source, &sink));
+        if !all_included_edges {
+            return false;
+        }
+        true
     }
 }
 
-/// Struct that ensures the implications of exclusions.
-/// For example, that nodes frome excluded files are not included, etc.
+// Filter implementation that includes everything.
 pub struct NoFilter;
 
 impl Filter for NoFilter {

stack-graphs/src/visualization.rs

@@ -15,6 +15,7 @@ use crate::partial::PartialPath;
 use crate::partial::PartialPaths;
 use crate::paths::Path;
 use crate::paths::Paths;
+use crate::stitching::Database;
 
 static CSS: &'static str = include_str!("visualization/visualization.css");
 static D3: &'static str = include_str!("visualization/d3.v7.min.js");
@@ -31,12 +32,13 @@ impl StackGraph {
     pub fn to_html_string(
         &self,
         title: &str,
-        paths: &mut Paths,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         filter: &dyn Filter,
     ) -> Result<String, JsonError> {
         let filter = VisualizationFilter(filter);
         let graph = self.to_json(&filter).to_string()?;
-        let paths = paths.to_json(self, &filter).to_string()?;
+        let paths = db.to_json(self, partials, &filter).to_string()?;
         let html = format!(
             r#"
 <!DOCTYPE html>
@@ -151,11 +153,14 @@ impl Filter for VisualizationFilter<'_> {
         if !self.0.include_partial_path(graph, paths, path) {
             return false;
         }
-        if path.start_node == path.end_node {
+        if path.start_node == path.end_node && path.edges.len() == 0 {
             return false;
         }
         if !match &graph[path.start_node] {
-            Node::PushScopedSymbol(_) | Node::PushSymbol(_) => true,
+            Node::PushScopedSymbol(_) | Node::PushSymbol(_) => {
+                path.symbol_stack_precondition.can_match_empty()
+                    && path.scope_stack_precondition.can_match_empty()
+            }
             Node::Root(_) => true,
             Node::Scope(node) => node.is_exported,
             _ => false,
@@ -164,8 +169,8 @@ impl Filter for VisualizationFilter<'_> {
         }
         if !match &graph[path.end_node] {
             Node::PopScopedSymbol(_) | Node::PopSymbol(_) => {
-                path.symbol_stack_postcondition.contains_symbols()
-                    && path.scope_stack_postcondition.contains_scopes()
+                path.symbol_stack_postcondition.can_match_empty()
+                    && path.scope_stack_postcondition.can_match_empty()
             }
             Node::Root(_) => true,
             Node::Scope(node) => node.is_exported,

tree-sitter-stack-graphs/src/cli/test.rs

@@ -14,7 +14,9 @@ use stack_graphs::arena::Handle;
 use stack_graphs::graph::File;
 use stack_graphs::graph::StackGraph;
 use stack_graphs::json::Filter;
-use stack_graphs::paths::Paths;
+use stack_graphs::partial::PartialPaths;
+use stack_graphs::stitching::Database;
+use stack_graphs::stitching::ForwardPartialPathStitcher;
 use std::path::Path;
 use std::path::PathBuf;
 use tree_sitter_graph::Variables;
@@ -269,17 +271,21 @@ impl TestArgs {
                 ));
             }
         }
-        let result = test.run(cancellation_flag)?;
+        let mut partials = PartialPaths::new();
+        let mut db = Database::new();
+        let result = test.run(&mut partials, &mut db, cancellation_flag)?;
         let success = self.handle_result(&result, &mut file_status)?;
         if self.output_mode.test(!success) {
             let files = test.fragments.iter().map(|f| f.file).collect::<Vec<_>>();
             self.save_output(
                 test_root,
                 test_path,
                 &test.graph,
-                &mut test.paths,
+                &mut partials,
+                &mut db,
                 &|_: &StackGraph, h: &Handle<File>| files.contains(h),
                 success,
+                cancellation_flag,
             )?;
         }
         Ok(result)
@@ -343,36 +349,47 @@ impl TestArgs {
         test_root: &Path,
         test_path: &Path,
         graph: &StackGraph,
-        paths: &mut Paths,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         filter: &dyn Filter,
         success: bool,
+        cancellation_flag: &dyn CancellationFlag,
     ) -> anyhow::Result<()> {
-        if let Some(path) = self
+        let save_graph = self
             .save_graph
             .as_ref()
-            .map(|spec| spec.format(test_root, test_path))
-        {
+            .map(|spec| spec.format(test_root, test_path));
+        let save_paths = self
+            .save_paths
+            .as_ref()
+            .map(|spec| spec.format(test_root, test_path));
+        let save_visualization = self
+            .save_visualization
+            .as_ref()
+            .map(|spec| spec.format(test_root, test_path));
+
+        if let Some(path) = save_graph {
             self.save_graph(&path, &graph, filter)?;
             if !success || !self.quiet {
                 println!("{}: graph at {}", test_path.display(), path.display());
             }
         }
-        if let Some(path) = self
-            .save_paths
-            .as_ref()
-            .map(|spec| spec.format(test_root, test_path))
-        {
-            self.save_paths(&path, paths, graph, filter)?;
+
+        let mut db = if save_paths.is_some() || save_visualization.is_some() {
+            self.compute_paths(graph, partials, db, filter, cancellation_flag)?
+        } else {
+            Database::new()
+        };
+
+        if let Some(path) = save_paths {
+            self.save_paths(&path, graph, partials, &mut db, filter)?;
             if !success || !self.quiet {
                 println!("{}: paths at {}", test_path.display(), path.display());
             }
         }
-        if let Some(path) = self
-            .save_visualization
-            .as_ref()
-            .map(|spec| spec.format(test_root, test_path))
-        {
-            self.save_visualization(&path, paths, graph, filter, &test_path)?;
+
+        if let Some(path) = save_visualization {
+            self.save_visualization(&path, graph, partials, &mut db, filter, &test_path)?;
             if !success || !self.quiet {
                 println!(
                     "{}: visualization at {}",
@@ -399,14 +416,41 @@ impl TestArgs {
         Ok(())
     }
 
+    fn compute_paths(
+        &self,
+        graph: &StackGraph,
+        partials: &mut PartialPaths,
+        db: &mut Database,
+        filter: &dyn Filter,
+        cancellation_flag: &dyn CancellationFlag,
+    ) -> anyhow::Result<Database> {
+        let references = graph
+            .iter_nodes()
+            .filter(|n| filter.include_node(graph, n))
+            .collect::<Vec<_>>();
+        let paths = ForwardPartialPathStitcher::find_all_complete_partial_paths(
+            graph,
+            partials,
+            db,
+            references.clone(),
+            &cancellation_flag,
+        )?;
+        let mut db = Database::new();
+        for path in paths {
+            db.add_partial_path(graph, partials, path);
+        }
+        Ok(db)
+    }
+
     fn save_paths(
         &self,
         path: &Path,
-        paths: &mut Paths,
         graph: &StackGraph,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         filter: &dyn Filter,
     ) -> anyhow::Result<()> {
-        let json = paths.to_json(graph, filter).to_string_pretty()?;
+        let json = db.to_json(graph, partials, filter).to_string_pretty()?;
         if let Some(dir) = path.parent() {
             std::fs::create_dir_all(dir)?;
         }
@@ -418,12 +462,13 @@ impl TestArgs {
     fn save_visualization(
         &self,
         path: &Path,
-        paths: &mut Paths,
         graph: &StackGraph,
+        paths: &mut PartialPaths,
+        db: &mut Database,
         filter: &dyn Filter,
         test_path: &Path,
     ) -> anyhow::Result<()> {
-        let html = graph.to_html_string(&format!("{}", test_path.display()), paths, filter)?;
+        let html = graph.to_html_string(&format!("{}", test_path.display()), paths, db, filter)?;
         if let Some(dir) = path.parent() {
             std::fs::create_dir_all(dir)?;
         }

tree-sitter-stack-graphs/src/test.rs

@@ -72,7 +72,8 @@ use stack_graphs::graph::File;
 use stack_graphs::graph::Node;
 use stack_graphs::graph::SourceInfo;
 use stack_graphs::graph::StackGraph;
-use stack_graphs::paths::Paths;
+use stack_graphs::partial::PartialPaths;
+use stack_graphs::stitching::Database;
 use std::collections::HashMap;
 use std::path::Path;
 use std::path::PathBuf;
@@ -149,7 +150,6 @@ pub struct Test {
     pub path: PathBuf,
     pub fragments: Vec<TestFragment>,
     pub graph: StackGraph,
-    pub paths: Paths,
 }
 
 /// A fragment from a stack graph test
@@ -269,7 +269,6 @@ impl Test {
             path: path.to_path_buf(),
             fragments,
             graph,
-            paths: Paths::new(),
         })
     }
 
@@ -623,13 +622,28 @@ impl Test {
     /// the test.
     pub fn run(
         &mut self,
+        partials: &mut PartialPaths,
+        db: &mut Database,
         cancellation_flag: &dyn CancellationFlag,
     ) -> Result<TestResult, stack_graphs::CancellationError> {
+        // build partial paths
+        for file in self.graph.iter_files() {
+            partials.find_all_partial_paths_in_file(
+                &self.graph,
+                file,
+                &cancellation_flag,
+                |g, ps, p| {
+                    db.add_partial_path(g, ps, p);
+                },
+            )?;
+        }
+
+        // test assertions
         let mut result = TestResult::new();
         for fragment in &self.fragments {
             for assertion in &fragment.assertions {
                 match assertion
-                    .run(&self.graph, &mut self.paths, &cancellation_flag)
+                    .run(&self.graph, partials, db, &cancellation_flag)
                     .map_or_else(|e| self.from_error(e), |v| Ok(v))
                 {
                     Ok(_) => result.add_success(),