Use separate names for list of appended things, and the arena

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -158,7 +158,7 @@ pub struct AppendingCycleDetector<A> {
     appendages: List<A>,
 }
 
-pub type Appendages<A> = ListArena<A>;
+pub type Appendables<A> = ListArena<A>;
 
 impl<A: Appendable + Clone> AppendingCycleDetector<A> {
     pub fn new() -> Self {
@@ -167,9 +167,9 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
         }
     }
 
-    pub fn from(appendages: &mut Appendages<A>, appendage: A) -> Self {
+    pub fn from(appendables: &mut Appendables<A>, appendage: A) -> Self {
         let mut result = Self::new();
-        result.appendages.push_front(appendages, appendage);
+        result.appendages.push_front(appendables, appendage);
         result
     }
 
@@ -178,11 +178,11 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         ctx: &mut A::Ctx,
-        appendages: &mut Appendages<A>,
+        appendables: &mut Appendables<A>,
         appendage: A,
     ) -> Result<(), PathResolutionError> {
         let end_node = appendage.end_node(ctx);
-        self.appendages.push_front(appendages, appendage);
+        self.appendages.push_front(appendables, appendage);
 
         let mut maybe_cyclic_path = None;
         let mut index = self.appendages;
@@ -191,7 +191,7 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
             // find loop point
             let mut count = 0usize;
             loop {
-                match index.pop_front(appendages) {
+                match index.pop_front(appendables) {
                     Some(appendage) => {
                         count += 1;
                         if appendage.start_node(ctx) == end_node {
@@ -205,13 +205,13 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
             // get prefix edges
             let mut prefix_appendages = List::empty();
             for _ in 0..count {
-                let appendage = values.pop_front(appendages).unwrap();
-                prefix_appendages.push_front(appendages, appendage.clone());
+                let appendage = values.pop_front(appendables).unwrap();
+                prefix_appendages.push_front(appendables, appendage.clone());
             }
 
             // build prefix path -- prefix starts at end_node, because this is a cycle
             let mut prefix_path = PartialPath::from_node(graph, partials, end_node);
-            while let Some(appendage) = prefix_appendages.pop_front(appendages) {
+            while let Some(appendage) = prefix_appendages.pop_front(appendables) {
                 prefix_path
                     .resolve_to(graph, partials, appendage.start_node(ctx))
                     .unwrap();

stack-graphs/src/partial.rs

@@ -45,7 +45,7 @@ use smallvec::SmallVec;
 use crate::arena::Deque;
 use crate::arena::DequeArena;
 use crate::arena::Handle;
-use crate::cycles::Appendages;
+use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
 use crate::graph::Edge;
@@ -2383,7 +2383,7 @@ impl PartialPath {
         graph: &StackGraph,
         partials: &mut PartialPaths,
         file: Handle<File>,
-        edges: &mut Appendages<Edge>,
+        edges: &mut Appendables<Edge>,
         path_cycle_detector: AppendingCycleDetector<Edge>,
         result: &mut R,
     ) {
@@ -2700,7 +2700,7 @@ 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 = Appendages::new();
+        let mut edges = Appendables::new();
         queue.extend(
             graph
                 .nodes_for_file(file)

stack-graphs/src/stitching.rs

@@ -48,7 +48,7 @@ use crate::arena::List;
 use crate::arena::ListArena;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
-use crate::cycles::Appendages;
+use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
 use crate::graph::Node;
@@ -726,7 +726,7 @@ pub struct ForwardPartialPathStitcher {
         VecDeque<PartialPath>,
         VecDeque<AppendingCycleDetector<OwnedOrDatabasePath>>,
     ),
-    appended_paths: Appendages<OwnedOrDatabasePath>,
+    appended_paths: Appendables<OwnedOrDatabasePath>,
     similar_path_detector: SimilarPathDetector<PartialPath>,
     max_work_per_phase: usize,
     #[cfg(feature = "copious-debugging")]
@@ -776,7 +776,7 @@ impl ForwardPartialPathStitcher {
                 );
             }
         }
-        let mut appended_paths = Appendages::new();
+        let mut appended_paths = Appendables::new();
         let next_iteration = candidate_partial_paths
             .iter()
             .copied()
@@ -817,7 +817,7 @@ impl ForwardPartialPathStitcher {
         _db: &mut Database,
         initial_partial_paths: Vec<PartialPath>,
     ) -> ForwardPartialPathStitcher {
-        let mut appended_paths = Appendages::new();
+        let mut appended_paths = Appendables::new();
         let next_iteration = initial_partial_paths
             .into_iter()
             .map(|p| {

stack-graphs/tests/it/cycles.rs

@@ -5,7 +5,7 @@
 // Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
 // ------------------------------------------------------------------------------------------------
 
-use stack_graphs::cycles::Appendages;
+use stack_graphs::cycles::Appendables;
 use stack_graphs::cycles::AppendingCycleDetector;
 use stack_graphs::graph::StackGraph;
 use stack_graphs::partial::PartialPaths;
@@ -147,7 +147,7 @@ fn finding_simple_identity_cycle_is_detected() {
 
     // test edge cycle detector
     {
-        let mut edges = Appendages::new();
+        let mut edges = Appendables::new();
         let mut cd = AppendingCycleDetector::new();
         let ctx = &mut ();
         assert!(cd
@@ -198,7 +198,7 @@ fn stitching_simple_identity_cycle_is_detected() {
 
     // test partial path cycle detector
     {
-        let mut paths = Appendages::new();
+        let mut paths = Appendables::new();
         let mut cd: AppendingCycleDetector<OwnedOrDatabasePath> =
             AppendingCycleDetector::from(&mut paths, p0.into());
         assert!(cd
@@ -228,7 +228,7 @@ fn finding_composite_identity_cycle_is_detected() {
 
     // test edge cycle detector
     {
-        let mut edges = Appendages::new();
+        let mut edges = Appendables::new();
         let mut cd = AppendingCycleDetector::new();
         let ctx = &mut ();
         assert!(cd
@@ -303,7 +303,7 @@ fn stitching_composite_identity_cycle_is_detected() {
 
     // test joining cycle detector
     {
-        let mut paths = Appendages::new();
+        let mut paths = Appendables::new();
         let mut cd: AppendingCycleDetector<OwnedOrDatabasePath> =
             AppendingCycleDetector::from(&mut paths, p0.into());
         assert!(cd