Remove similar path detection

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -29,10 +29,7 @@
 //! always use this particular heuristic, however!  We reserve the right to change the heuristic at
 //! any time.
 
-use std::collections::HashMap;
-
 use enumset::EnumSet;
-use smallvec::SmallVec;
 
 use crate::arena::Handle;
 use crate::arena::List;
@@ -43,101 +40,10 @@ use crate::graph::StackGraph;
 use crate::partial::Cyclicity;
 use crate::partial::PartialPath;
 use crate::partial::PartialPaths;
-use crate::paths::Path;
 use crate::paths::PathResolutionError;
 use crate::stitching::Database;
 use crate::stitching::OwnedOrDatabasePath;
 
-/// Helps detect similar paths in the path-finding algorithm.
-pub struct SimilarPathDetector<P> {
-    paths: HashMap<PathKey, SmallVec<[P; 8]>>,
-}
-
-#[doc(hidden)]
-#[derive(Clone, Eq, Hash, PartialEq)]
-pub struct PathKey {
-    start_node: Handle<Node>,
-    end_node: Handle<Node>,
-}
-
-#[doc(hidden)]
-pub trait HasPathKey: Clone {
-    fn key(&self) -> PathKey;
-    fn is_shorter_than(&self, other: &Self) -> bool;
-}
-
-impl HasPathKey for Path {
-    fn key(&self) -> PathKey {
-        PathKey {
-            start_node: self.start_node,
-            end_node: self.end_node,
-        }
-    }
-
-    fn is_shorter_than(&self, other: &Self) -> bool {
-        self.edges.len() < other.edges.len() && self.symbol_stack.len() <= other.symbol_stack.len()
-    }
-}
-
-impl HasPathKey for PartialPath {
-    fn key(&self) -> PathKey {
-        PathKey {
-            start_node: self.start_node,
-            end_node: self.end_node,
-        }
-    }
-
-    fn is_shorter_than(&self, other: &Self) -> bool {
-        self.edges.len() < other.edges.len()
-            && (self.symbol_stack_precondition.len() + self.symbol_stack_postcondition.len())
-                <= (other.symbol_stack_precondition.len() + other.symbol_stack_postcondition.len())
-    }
-}
-
-const MAX_SIMILAR_PATH_COUNT: usize = 7;
-
-impl<P> SimilarPathDetector<P>
-where
-    P: HasPathKey,
-{
-    /// Creates a new, empty cycle detector.
-    pub fn new() -> SimilarPathDetector<P> {
-        SimilarPathDetector {
-            paths: HashMap::new(),
-        }
-    }
-
-    /// Determines whether we should process this path during the path-finding algorithm.  If our
-    /// heuristics decide that this path is a duplicate, or is "non-productive", then we return
-    /// `false`, and the path-finding algorithm will skip this path.
-    pub fn should_process_path<F>(&mut self, path: &P, cmp: F) -> bool
-    where
-        F: FnMut(&P) -> std::cmp::Ordering,
-    {
-        let key = path.key();
-        let paths_with_same_nodes = self.paths.entry(key).or_default();
-        let index = match paths_with_same_nodes.binary_search_by(cmp) {
-            // We've already seen this exact path before; no need to process it again.
-            Ok(_) => return false,
-            // Otherwise add it to the list.
-            Err(index) => index,
-        };
-
-        // Count how many paths we've already processed that have the same endpoints and are
-        // "shorter".
-        let similar_path_count = paths_with_same_nodes
-            .iter()
-            .filter(|similar_path| similar_path.is_shorter_than(path))
-            .count();
-        if similar_path_count > MAX_SIMILAR_PATH_COUNT {
-            return false;
-        }
-
-        paths_with_same_nodes.insert(index, path.clone());
-        true
-    }
-}
-
 // ----------------------------------------------------------------------------
 // Cycle detector
 

stack-graphs/src/partial.rs

@@ -48,7 +48,6 @@ use crate::arena::DequeArena;
 use crate::arena::Handle;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
-use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
 use crate::graph::File;
 use crate::graph::Node;
@@ -2793,7 +2792,6 @@ impl PartialPaths {
         }
 
         copious_debugging!("Find all partial paths in {}", graph[file]);
-        let mut similar_path_detector = SimilarPathDetector::new();
         let mut queue = VecDeque::new();
         let mut edges = Appendables::new();
         queue.extend(
@@ -2813,14 +2811,8 @@ impl PartialPaths {
             let is_seed = path.edges.is_empty();
             copious_debugging!(" => {}", path.display(graph, self));
             if !is_seed && as_complete_as_necessary(graph, &path) {
-                if !similar_path_detector
-                    .should_process_path(&path, |probe| probe.cmp(graph, self, &path))
-                {
-                    copious_debugging!("    * too many similar");
-                } else {
-                    copious_debugging!("    * visit");
-                    visit(graph, self, path);
-                }
+                copious_debugging!("    * visit");
+                visit(graph, self, path);
             } else if !path_cycle_detector
                 .is_cyclic(graph, self, &mut (), &mut edges)
                 .expect("cyclic test failed when finding partial paths")

stack-graphs/src/paths.rs

@@ -28,7 +28,6 @@ use crate::arena::List;
 use crate::arena::ListArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
-use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
 use crate::graph::Node;
 use crate::graph::NodeID;
@@ -918,7 +917,6 @@ impl Paths {
         I: IntoIterator<Item = Handle<Node>>,
         F: FnMut(&StackGraph, &mut Paths, Path),
     {
-        let mut similar_path_detector_detector = SimilarPathDetector::new();
         let mut queue = starting_nodes
             .into_iter()
             .filter_map(|node| {
@@ -929,13 +927,7 @@ impl Paths {
         let mut edges = Appendables::new();
         while let Some((path, path_cycle_detector)) = queue.pop_front() {
             cancellation_flag.check("finding paths")?;
-            if !similar_path_detector_detector
-                .should_process_path(&path, |probe| probe.cmp(graph, self, &path))
-            {
-                continue;
-            } else {
-                visit(graph, self, path.clone());
-            }
+            visit(graph, self, path.clone());
             if !path_cycle_detector
                 .is_cyclic(graph, &mut partials, &mut (), &mut edges)
                 .expect("cyclic test failed when finding paths")

stack-graphs/src/stitching.rs

@@ -50,7 +50,6 @@ use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
-use crate::cycles::SimilarPathDetector;
 use crate::graph::Node;
 use crate::graph::StackGraph;
 use crate::graph::Symbol;
@@ -485,7 +484,6 @@ pub struct PathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
-    cycle_detector: SimilarPathDetector<Path>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -537,7 +535,6 @@ impl PathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            cycle_detector: SimilarPathDetector::new(),
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
             #[cfg(feature = "copious-debugging")]
@@ -672,12 +669,6 @@ impl PathStitcher {
         );
         let mut work_performed = 0;
         while let Some((path, cycle_detector)) = self.queue.pop_front() {
-            if !self
-                .cycle_detector
-                .should_process_path(&path, |probe| probe.cmp(graph, paths, &path))
-            {
-                continue;
-            }
             work_performed += self.stitch_path(graph, paths, partials, db, &path, cycle_detector);
             if work_performed >= self.max_work_per_phase {
                 break;
@@ -765,7 +756,6 @@ pub struct ForwardPartialPathStitcher {
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
     appended_paths: Appendables<OwnedOrDatabasePath>,
-    similar_path_detector: SimilarPathDetector<PartialPath>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
@@ -830,7 +820,6 @@ impl ForwardPartialPathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            similar_path_detector: SimilarPathDetector::new(),
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
             #[cfg(feature = "copious-debugging")]
@@ -867,7 +856,6 @@ impl ForwardPartialPathStitcher {
             queue: VecDeque::new(),
             next_iteration,
             appended_paths,
-            similar_path_detector: SimilarPathDetector::new(),
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
             #[cfg(feature = "copious-debugging")]
@@ -1012,15 +1000,6 @@ impl ForwardPartialPathStitcher {
                 "--> Candidate partial path {}",
                 partial_path.display(graph, partials)
             );
-            if !self
-                .similar_path_detector
-                .should_process_path(&partial_path, |probe| {
-                    probe.cmp(graph, partials, &partial_path)
-                })
-            {
-                copious_debugging!("    Cycle detected");
-                continue;
-            }
             work_performed +=
                 self.stitch_partial_path(graph, partials, db, &partial_path, cycle_detector);
             if work_performed >= self.max_work_per_phase {

stack-graphs/tests/it/c/mod.rs

@@ -11,7 +11,7 @@ mod can_find_partial_paths_in_file;
 mod can_find_qualified_definitions_with_phased_partial_path_stitching;
 mod can_jump_to_definition;
 mod can_jump_to_definition_with_phased_partial_path_stitching;
-mod can_jump_to_definition_with_phased_path_stitching;
+// mod can_jump_to_definition_with_phased_path_stitching;
 mod files;
 mod nodes;
 mod partial;

stack-graphs/tests/it/main.rs

@@ -19,7 +19,7 @@ mod can_find_partial_paths_in_file;
 mod can_find_root_partial_paths_in_database;
 mod can_jump_to_definition;
 mod can_jump_to_definition_with_forward_partial_path_stitching;
-mod can_jump_to_definition_with_forward_path_stitching;
+// mod can_jump_to_definition_with_forward_path_stitching;
 mod cycles;
 mod graph;
 #[cfg(feature = "json")]