Use path convenience methods in more places

Author: Hendrik van Antwerpen

stack-graphs/src/partial.rs

@@ -2063,6 +2063,10 @@ impl PartialPath {
         graph[self.end_node].is_endpoint()
     }
 
+    pub fn ends_in_jump(&self, graph: &StackGraph) -> bool {
+        graph[self.end_node].is_jump_to()
+    }
+
     /// Returns whether a partial path is "productive" — that is, whether it adds useful
     /// information to a path.  Non-productive paths are ignored.
     pub fn is_productive(&self, partials: &mut PartialPaths) -> bool {
@@ -2505,7 +2509,7 @@ impl PartialPaths {
         );
         while let Some(path) = queue.pop_front() {
             cancellation_flag.check("finding partial paths in file")?;
-            let is_seed = path.start_node == path.end_node && path.edges.len() == 0;
+            let is_seed = path.edges.is_empty();
             copious_debugging!(" => {}", path.display(graph, self));
             if !is_seed && as_complete_as_necessary(graph, &path) {
                 copious_debugging!("    * as complete as necessary");

stack-graphs/src/paths.rs

@@ -651,19 +651,31 @@ impl Path {
             .then_with(|| self.edges.cmp(paths, other.edges))
     }
 
+    pub fn starts_at_reference(&self, graph: &StackGraph) -> bool {
+        graph[self.start_node].is_reference()
+    }
+
+    pub fn ends_at_definition(&self, graph: &StackGraph) -> bool {
+        graph[self.end_node].is_definition()
+            && self.symbol_stack.is_empty()
+            && self.scope_stack.is_empty()
+    }
+
+    pub fn starts_at_endpoint(&self, graph: &StackGraph) -> bool {
+        graph[self.start_node].is_endpoint()
+    }
+
+    pub fn ends_at_endpoint(&self, graph: &StackGraph) -> bool {
+        graph[self.end_node].is_endpoint()
+    }
+
+    pub fn ends_in_jump(&self, graph: &StackGraph) -> bool {
+        graph[self.end_node].is_jump_to()
+    }
+
     /// A _complete_ path represents a full name binding that resolves a reference to a definition.
     pub fn is_complete(&self, graph: &StackGraph) -> bool {
-        if !graph[self.start_node].is_reference() {
-            return false;
-        } else if !graph[self.end_node].is_definition() {
-            return false;
-        } else if !self.symbol_stack.is_empty() {
-            return false;
-        } else if !self.scope_stack.is_empty() {
-            return false;
-        } else {
-            true
-        }
+        self.starts_at_reference(graph) && self.ends_at_definition(graph)
     }
 
     pub fn display<'a>(&'a self, graph: &'a StackGraph, paths: &'a mut Paths) -> impl Display + 'a {

stack-graphs/src/stitching.rs

@@ -1052,7 +1052,7 @@ impl ForwardPartialPathStitcher {
         let mut stitcher =
             ForwardPartialPathStitcher::from_nodes(graph, partials, db, starting_nodes);
         stitcher.should_extend =
-            Box::new(|g, _ps, p| p.edges.len() == 0 || !g[p.end_node].is_root());
+            Box::new(|g, _ps, p| p.edges.is_empty() || !g[p.end_node].is_root());
         while !stitcher.is_complete() {
             cancellation_flag.check("finding complete partial paths")?;
             let partial_paths = stitcher

stack-graphs/src/visualization.rs

@@ -117,31 +117,10 @@ impl Filter for VisualizationFilter<'_> {
     }
 
     fn include_path(&self, graph: &StackGraph, paths: &Paths, path: &Path) -> bool {
-        if !self.0.include_path(graph, paths, path) {
-            return false;
-        }
-        if path.start_node == path.end_node {
-            return false;
-        }
-        if !match &graph[path.start_node] {
-            Node::PushScopedSymbol(_) | Node::PushSymbol(_) => true,
-            Node::Root(_) => true,
-            Node::Scope(node) => node.is_exported,
-            _ => false,
-        } {
-            return false;
-        }
-        if !match &graph[path.end_node] {
-            Node::PopScopedSymbol(_) | Node::PopSymbol(_) => {
-                path.symbol_stack.is_empty() && path.scope_stack.is_empty()
-            }
-            Node::Root(_) => true,
-            Node::Scope(node) => node.is_exported,
-            _ => false,
-        } {
-            return false;
-        }
-        return true;
+        self.0.include_path(graph, paths, path)
+            && !path.edges.is_empty()
+            && path.starts_at_reference(graph)
+            && (path.ends_at_definition(graph) || path.ends_in_jump(graph))
     }
 
     fn include_partial_path(
@@ -150,34 +129,9 @@ impl Filter for VisualizationFilter<'_> {
         paths: &PartialPaths,
         path: &PartialPath,
     ) -> bool {
-        if !self.0.include_partial_path(graph, paths, path) {
-            return false;
-        }
-        if path.start_node == path.end_node && path.edges.len() == 0 {
-            return false;
-        }
-        if !match &graph[path.start_node] {
-            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,
-        } {
-            return false;
-        }
-        if !match &graph[path.end_node] {
-            Node::PopScopedSymbol(_) | Node::PopSymbol(_) => {
-                path.symbol_stack_postcondition.can_match_empty()
-                    && path.scope_stack_postcondition.can_match_empty()
-            }
-            Node::Root(_) => true,
-            Node::Scope(node) => node.is_exported,
-            _ => false,
-        } {
-            return false;
-        }
-        return true;
+        self.0.include_partial_path(graph, paths, path)
+            && !path.edges.is_empty()
+            && path.starts_at_reference(graph)
+            && (path.ends_at_definition(graph) || path.ends_in_jump(graph))
     }
 }