Generalize ForwardPartialPathStitcher

Author: Hendrik van Antwerpen

stack-graphs/src/assert.rs

@@ -178,7 +178,7 @@ impl Assertion {
         let mut actual_paths = Vec::new();
         for reference in &references {
             let mut reference_paths = Vec::new();
-            ForwardPartialPathStitcher::find_all_complete_partial_paths(
+            ForwardPartialPathStitcher::<Handle<PartialPath>>::find_all_complete_partial_paths(
                 graph,
                 partials,
                 db,

stack-graphs/src/c.rs

@@ -1404,12 +1404,12 @@ struct InternalForwardPartialPathStitcher {
     previous_phase_partial_paths: *const PartialPath,
     previous_phase_partial_paths_length: usize,
     is_complete: bool,
-    stitcher: ForwardPartialPathStitcher,
+    stitcher: ForwardPartialPathStitcher<Handle<PartialPath>>,
 }
 
 impl InternalForwardPartialPathStitcher {
     fn new(
-        stitcher: ForwardPartialPathStitcher,
+        stitcher: ForwardPartialPathStitcher<Handle<PartialPath>>,
         partials: &mut PartialPaths,
     ) -> InternalForwardPartialPathStitcher {
         let mut this = InternalForwardPartialPathStitcher {

stack-graphs/src/cycles.rs

@@ -31,7 +31,6 @@
 
 use enumset::EnumSet;
 use smallvec::SmallVec;
-use std::borrow::Cow;
 use std::collections::HashMap;
 
 use crate::arena::Handle;
@@ -129,22 +128,22 @@ where
 // ----------------------------------------------------------------------------
 // Cycle detector
 
-pub trait Index<'a, H, A>
+pub trait Index<H, A>
 where
-    A: Appendable + Clone + 'a,
+    A: Appendable + Clone,
 {
-    fn get(&'a self, handle: &H) -> Cow<'a, A>;
+    fn get<'a>(&'a self, handle: &'a H) -> &'a A;
 }
 
-impl<'a> Index<'a, Handle<PartialPath>, PartialPath> for Database {
-    fn get(&'a self, handle: &Handle<PartialPath>) -> Cow<'a, PartialPath> {
-        Cow::Borrowed(&self[*handle])
+impl Index<Handle<PartialPath>, PartialPath> for Database {
+    fn get<'a>(&'a self, handle: &'a Handle<PartialPath>) -> &'a PartialPath {
+        &self[*handle]
     }
 }
 
-impl<'a, A: Appendable + Clone + 'a> Index<'a, A, A> for () {
-    fn get(&self, value: &A) -> Cow<'a, A> {
-        Cow::Owned(value.clone())
+impl<A: Appendable + Clone> Index<A, A> for () {
+    fn get<'a>(&'a self, value: &'a A) -> &'a A {
+        value
     }
 }
 
@@ -175,7 +174,7 @@ where
     ) -> Result<(), PathResolutionError>
     where
         A: Appendable + Clone + 'a,
-        Db: Index<'a, H, A>,
+        Db: Index<H, A>,
     {
         match self {
             Self::Path(other) => other.append_to(graph, partials, path),
@@ -186,7 +185,7 @@ where
     fn start_node<'a, A, Db>(&self, db: &'a Db) -> Handle<Node>
     where
         A: Appendable + Clone + 'a,
-        Db: Index<'a, H, A>,
+        Db: Index<H, A>,
     {
         match self {
             Self::Path(path) => path.start_node,
@@ -197,7 +196,7 @@ where
     fn end_node<'a, A, Db>(&self, db: &'a Db) -> Handle<Node>
     where
         A: Appendable + Clone + 'a,
-        Db: Index<'a, H, A>,
+        Db: Index<H, A>,
     {
         match self {
             Self::Path(path) => path.end_node,
@@ -247,7 +246,7 @@ where
     ) -> Result<EnumSet<Cyclicity>, PathResolutionError>
     where
         A: Appendable + Clone + 'a,
-        Db: Index<'a, H, A>,
+        Db: Index<H, A>,
     {
         let mut cycles = EnumSet::new();
 

stack-graphs/src/stitching.rs

@@ -153,6 +153,34 @@ impl Appendable for PartialPath {
     }
 }
 
+//-------------------------------------------------------------------------------------------------
+// Candidates
+
+pub trait Candidates<H> {
+    fn find_candidates<R>(
+        &mut self,
+        graph: &StackGraph,
+        partials: &mut PartialPaths,
+        path: &PartialPath,
+        result: &mut R,
+    ) where
+        R: std::iter::Extend<H>;
+}
+
+impl Candidates<Edge> for () {
+    fn find_candidates<R>(
+        &mut self,
+        graph: &StackGraph,
+        _partials: &mut PartialPaths,
+        path: &PartialPath,
+        result: &mut R,
+    ) where
+        R: std::iter::Extend<Edge>,
+    {
+        result.extend(graph.outgoing_edges(path.end_node));
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Databases
 
@@ -420,6 +448,31 @@ impl Index<Handle<PartialPath>> for Database {
     }
 }
 
+impl Candidates<Handle<PartialPath>> for Database {
+    fn find_candidates<R>(
+        &mut self,
+        graph: &StackGraph,
+        partials: &mut PartialPaths,
+        path: &PartialPath,
+        result: &mut R,
+    ) where
+        R: std::iter::Extend<Handle<PartialPath>>,
+    {
+        if graph[path.end_node].is_root() {
+            // The join node is root, so there's no need to use half-open symbol stacks here, as we
+            // do for [`PartialPath::concatenate`][].
+            let key = SymbolStackKey::from_partial_symbol_stack(
+                partials,
+                self,
+                path.symbol_stack_postcondition,
+            );
+            self.find_candidate_partial_paths_from_root(graph, partials, Some(key), result);
+        } else {
+            self.find_candidate_partial_paths_from_node(graph, partials, path.end_node, result);
+        }
+    }
+}
+
 /// The key type that we use to find partial paths that start from the root node and have a
 /// particular symbol stack as their precondition.
 #[derive(Clone, Copy)]
@@ -553,30 +606,23 @@ impl<'a> Display for DisplaySymbolStackKey<'a> {
 /// completion, using the [`find_all_complete_partial_paths`][] method.
 ///
 /// [`find_all_complete_partial_paths`]: #method.find_all_complete_partial_paths
-pub struct ForwardPartialPathStitcher {
-    candidate_partial_paths: Vec<Handle<PartialPath>>,
-    queue: VecDeque<(PartialPath, AppendingCycleDetector<Handle<PartialPath>>)>,
+pub struct ForwardPartialPathStitcher<H> {
+    candidates: Vec<H>,
+    queue: VecDeque<(PartialPath, AppendingCycleDetector<H>)>,
     // 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<Handle<PartialPath>>>,
-    ),
-    appended_paths: Appendables<Handle<PartialPath>>,
+    next_iteration: (VecDeque<PartialPath>, VecDeque<AppendingCycleDetector<H>>),
+    appended_paths: Appendables<H>,
     similar_path_detector: Option<SimilarPathDetector<PartialPath>>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
 }
 
-impl ForwardPartialPathStitcher {
+impl<H> ForwardPartialPathStitcher<H> {
     /// Creates a new forward partial path stitcher that is "seeded" with a set of starting stack
     /// graph nodes.
-    pub fn from_nodes<I>(
-        graph: &StackGraph,
-        partials: &mut PartialPaths,
-        starting_nodes: I,
-    ) -> ForwardPartialPathStitcher
+    pub fn from_nodes<I>(graph: &StackGraph, partials: &mut PartialPaths, starting_nodes: I) -> Self
     where
         I: IntoIterator<Item = Handle<Node>>,
     {
@@ -590,8 +636,8 @@ impl ForwardPartialPathStitcher {
                 (p, c)
             })
             .unzip();
-        ForwardPartialPathStitcher {
-            candidate_partial_paths: Vec::new(),
+        Self {
+            candidates: Vec::new(),
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
@@ -609,7 +655,7 @@ impl ForwardPartialPathStitcher {
         _graph: &StackGraph,
         partials: &mut PartialPaths,
         initial_partial_paths: Vec<PartialPath>,
-    ) -> ForwardPartialPathStitcher {
+    ) -> Self {
         let mut appended_paths = Appendables::new();
         let next_iteration = initial_partial_paths
             .into_iter()
@@ -619,8 +665,8 @@ impl ForwardPartialPathStitcher {
                 (p, c)
             })
             .unzip();
-        ForwardPartialPathStitcher {
-            candidate_partial_paths: Vec::new(),
+        Self {
+            candidates: Vec::new(),
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
@@ -631,7 +677,9 @@ impl ForwardPartialPathStitcher {
             phase_number: 1,
         }
     }
+}
 
+impl<H: Clone> ForwardPartialPathStitcher<H> {
     /// Returns an iterator of all of the (possibly incomplete) partial paths that were encountered
     /// during the most recent phase of the algorithm.
     pub fn previous_phase_partial_paths(&self) -> impl Iterator<Item = &PartialPath> + '_ {
@@ -676,60 +724,41 @@ impl ForwardPartialPathStitcher {
     /// Attempts to extend one partial path as part of the algorithm.  When calling this function,
     /// you are responsible for ensuring that `db` already contains all of the possible partial
     /// paths that we might want to extend `partial_path` with.
-    fn stitch_partial_path(
+    fn stitch_partial_path<'a, A, Db>(
         &mut self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
-        db: &mut Database,
+        db: &mut Db,
         partial_path: &PartialPath,
-        cycle_detector: AppendingCycleDetector<Handle<PartialPath>>,
-    ) -> usize {
-        self.candidate_partial_paths.clear();
-        if graph[partial_path.end_node].is_root() {
-            // The join node is root, so there's no need to use half-open symbol stacks here, as we
-            // do for [`PartialPath::concatenate`][].
-            let key = SymbolStackKey::from_partial_symbol_stack(
-                partials,
-                db,
-                partial_path.symbol_stack_postcondition,
-            );
-            db.find_candidate_partial_paths_from_root(
-                graph,
-                partials,
-                Some(key),
-                &mut self.candidate_partial_paths,
-            );
-        } else {
-            db.find_candidate_partial_paths_from_node(
-                graph,
-                partials,
-                partial_path.end_node,
-                &mut self.candidate_partial_paths,
-            );
-        }
+        cycle_detector: AppendingCycleDetector<H>,
+    ) -> usize
+    where
+        A: Appendable + Clone + 'a,
+        Db: Candidates<H> + crate::cycles::Index<H, A>,
+    {
+        self.candidates.clear();
+        db.find_candidates(graph, partials, partial_path, &mut self.candidates);
 
-        let extension_count = self.candidate_partial_paths.len();
+        let extension_count = self.candidates.len();
         self.next_iteration.0.reserve(extension_count);
         self.next_iteration.1.reserve(extension_count);
-        for extension in &self.candidate_partial_paths {
-            let mut extension_path = db[*extension].clone();
+        for extension in &self.candidates {
+            let extension_path = db.get(extension);
             copious_debugging!("    Extend {}", partial_path.display(graph, partials));
             copious_debugging!("      with {}", extension_path.display(graph, partials));
-            extension_path.ensure_no_overlapping_variables(partials, partial_path);
-            copious_debugging!("        -> {}", extension_path.display(graph, partials));
 
             let mut new_partial_path = partial_path.clone();
             let mut new_cycle_detector = cycle_detector.clone();
             // If there are errors concatenating these partial paths, or resolving the resulting
             // partial path, just skip the extension — it's not a fatal error.
             #[cfg_attr(not(feature = "copious-debugging"), allow(unused_variables))]
             {
-                if let Err(err) = new_partial_path.concatenate(graph, partials, &extension_path) {
+                if let Err(err) = extension_path.append_to(graph, partials, &mut new_partial_path) {
                     copious_debugging!("        is invalid: {:?}", err);
                     continue;
                 }
                 copious_debugging!("        is {}", new_partial_path.display(graph, partials));
-                new_cycle_detector.append(&mut self.appended_paths, *extension);
+                new_cycle_detector.append(&mut self.appended_paths, extension.clone());
                 let cycles = new_cycle_detector
                     .is_cyclic(graph, partials, db, &mut self.appended_paths)
                     .expect("cyclic test failed when stitching partial paths");
@@ -773,12 +802,15 @@ impl ForwardPartialPathStitcher {
     /// list of the (possibly incomplete) partial paths that were encountered during this phase.
     ///
     /// [`previous_phase_partial_paths`]: #method.previous_phase_partial_paths
-    pub fn process_next_phase(
+    pub fn process_next_phase<'a, A, Db>(
         &mut self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
-        db: &mut Database,
-    ) {
+        db: &mut Db,
+    ) where
+        A: Appendable + Clone + 'a,
+        Db: Candidates<H> + crate::cycles::Index<H, A>,
+    {
         copious_debugging!("==> Start phase {}", self.phase_number);
         self.queue.extend(
             self.next_iteration
@@ -811,7 +843,9 @@ impl ForwardPartialPathStitcher {
             self.phase_number += 1;
         }
     }
+}
 
+impl<H> ForwardPartialPathStitcher<H> {
     /// Returns all of the complete partial paths that are reachable from a set of starting nodes,
     /// building them up by stitching together partial paths from this database.
     ///

stack-graphs/tests/it/can_jump_to_definition_with_forward_partial_path_stitching.rs

@@ -8,7 +8,9 @@
 use std::collections::BTreeSet;
 
 use pretty_assertions::assert_eq;
+use stack_graphs::arena::Handle;
 use stack_graphs::graph::StackGraph;
+use stack_graphs::partial::PartialPath;
 use stack_graphs::partial::PartialPaths;
 use stack_graphs::stitching::Database;
 use stack_graphs::stitching::ForwardPartialPathStitcher;
@@ -38,7 +40,7 @@ fn check_jump_to_definition(graph: &StackGraph, expected_partial_paths: &[&str])
         .iter_nodes()
         .filter(|handle| graph[*handle].is_reference());
     let mut complete_partial_paths = Vec::new();
-    ForwardPartialPathStitcher::find_all_complete_partial_paths(
+    ForwardPartialPathStitcher::<Handle<PartialPath>>::find_all_complete_partial_paths(
         graph,
         &mut partials,
         &mut db,

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

@@ -13,6 +13,7 @@ use itertools::Itertools;
 use stack_graphs::arena::Handle;
 use stack_graphs::graph::File;
 use stack_graphs::graph::StackGraph;
+use stack_graphs::partial::PartialPath;
 use stack_graphs::partial::PartialPaths;
 use stack_graphs::serde::Filter;
 use stack_graphs::stitching::Database;
@@ -446,7 +447,7 @@ impl TestArgs {
             .filter(|n| filter.include_node(graph, n))
             .collect::<Vec<_>>();
         let mut paths = Vec::new();
-        ForwardPartialPathStitcher::find_all_complete_partial_paths(
+        ForwardPartialPathStitcher::<Handle<PartialPath>>::find_all_complete_partial_paths(
             graph,
             partials,
             db,