Merge pull request #177 from github/path-finding-mem

More partial path finding improvements

Author: Hendrik van Antwerpen

stack-graphs/src/arena.rs

@@ -315,6 +315,15 @@ impl<H, T> SupplementalArena<H, T> {
     pub fn len(&self) -> usize {
         self.items.len()
     }
+
+    /// Iterate over the items in this arena.
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (Handle<T>, &T)> {
+        self.items
+            .iter()
+            .enumerate()
+            .skip(1)
+            .map(|(i, x)| (Handle::from_some(i as u32), unsafe { &*(x.as_ptr()) }))
+    }
 }
 
 impl<H, T> SupplementalArena<H, T>

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,28 @@ 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 mut reference_paths = Vec::new();
+            ForwardPartialPathStitcher::find_all_complete_partial_paths(
+                graph,
+                partials,
+                db,
+                vec![*reference],
+                cancellation_flag,
+                |_, _, p| {
+                    reference_paths.push(p.clone());
+                },
+            )?;
+            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/c.rs

@@ -1576,17 +1576,45 @@ pub extern "C" fn sg_partial_path_arena_find_partial_paths_in_file(
     let partial_path_list = unsafe { &mut *partial_path_list };
     let cancellation_flag: Option<&AtomicUsize> =
         unsafe { std::mem::transmute(cancellation_flag.as_ref()) };
-    partials
-        .find_all_partial_paths_in_file(
-            graph,
-            file,
-            &AtomicUsizeCancellationFlag(cancellation_flag),
-            |_graph, partials, mut path| {
-                path.ensure_both_directions(partials);
-                partial_path_list.partial_paths.push(path);
-            },
-        )
-        .into()
+    sg_partial_path_arena_find_partial_paths_in_file_inner(
+        graph,
+        partials,
+        file,
+        partial_path_list,
+        &AtomicUsizeCancellationFlag(cancellation_flag),
+    )
+    .into()
+}
+
+fn sg_partial_path_arena_find_partial_paths_in_file_inner(
+    graph: &StackGraph,
+    partials: &mut PartialPaths,
+    file: Handle<File>,
+    partial_path_list: &mut sg_partial_path_list,
+    cancellation_flag: &dyn CancellationFlag,
+) -> Result<(), CancellationError> {
+    let mut db = Database::new();
+    partials.find_minimal_partial_paths_set_in_file(
+        graph,
+        file,
+        cancellation_flag,
+        |graph, partials, path| {
+            db.add_partial_path(graph, partials, path);
+        },
+    )?;
+    #[allow(deprecated)]
+    ForwardPartialPathStitcher::find_locally_complete_partial_paths(
+        graph,
+        partials,
+        &mut db,
+        cancellation_flag,
+        |_graph, partials, path| {
+            let mut path = path.clone();
+            path.ensure_both_directions(partials);
+            partial_path_list.partial_paths.push(path);
+        },
+    )?;
+    Ok(())
 }
 
 /// A handle to a partial path in a partial path database.  A zero handle represents a missing

stack-graphs/src/graph.rs

@@ -579,6 +579,11 @@ impl Node {
         matches!(self, Node::Root(_))
     }
 
+    #[inline(always)]
+    pub fn is_endpoint(&self) -> bool {
+        self.is_definition() || self.is_exported_scope() || self.is_reference() || self.is_root()
+    }
+
     /// Returns this node's symbol, if it has one.  (_Pop symbol_, _pop scoped symbol_, _push
     /// symbol_, and _push scoped symbol_ nodes have symbols.)
     pub fn symbol(&self) -> Option<Handle<Symbol>> {