Clarify various resolve method names and add test

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -216,14 +216,14 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
             // 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(appendables) {
-                prefix_path.resolve_to(graph, partials, appendage.start_node(ctx))?;
+                prefix_path.resolve_to_node(graph, partials, appendage.start_node(ctx))?;
                 appendage.append_to(graph, partials, ctx, &mut prefix_path)?;
             }
 
             // build cyclic path
             let cyclic_path = maybe_cyclic_path
                 .unwrap_or_else(|| PartialPath::from_node(graph, partials, end_node));
-            prefix_path.resolve_to(graph, partials, cyclic_path.start_node)?;
+            prefix_path.resolve_to_node(graph, partials, cyclic_path.start_node)?;
             prefix_path.ensure_no_overlapping_variables(partials, &cyclic_path);
             prefix_path.concatenate(graph, partials, &cyclic_path)?;
             if let Some(cyclicity) = prefix_path.is_cyclic(graph, partials) {

stack-graphs/src/partial.rs

@@ -2371,15 +2371,15 @@ impl PartialPath {
             },
         );
 
-        self.resolve(graph, partials)?;
+        self.resolve_from_postcondition(graph, partials)?;
 
         Ok(())
     }
 
-    /// Attempts to resolve any _jump to scope_ node at the end of a partial path.  If the partial
-    /// path does not end in a _jump to scope_ node, we do nothing.  If it does, and we cannot
-    /// resolve it, then we return an error describing why.
-    pub fn resolve(
+    /// Attempts to resolve any _jump to scope_ node at the end of a partial path from the postcondition
+    /// scope stack.  If the partial path does not end in a _jump to scope_ node, we do nothing.  If it
+    /// does, and we cannot resolve it, then we return an error describing why.
+    pub fn resolve_from_postcondition(
         &mut self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
@@ -2405,10 +2405,11 @@ impl PartialPath {
         Ok(())
     }
 
-    /// Attempts to resolve any _jump to scope_ node at the end of a partial path to the given node.
-    /// If the partial path does not end in a _jump to scope_ node, we do nothing.  If it does, and we
-    /// cannot resolve it, then we return an error describing why.
-    pub fn resolve_to(
+    /// Resolve any _jump to scope_ node at the end of a partial path to the given node, updating the
+    /// precondition to include the given node.  If the partial path does not end in a _jump to scope_
+    /// node, we do nothing.  If it does, and we cannot resolve it, then we return an error describing
+    /// why.
+    pub fn resolve_to_node(
         &mut self,
         graph: &StackGraph,
         partials: &mut PartialPaths,
@@ -2971,7 +2972,7 @@ impl PartialPath {
         }
         lhs.end_node = rhs.end_node;
 
-        lhs.resolve(graph, partials)?;
+        lhs.resolve_from_postcondition(graph, partials)?;
 
         Ok(())
     }

stack-graphs/tests/it/partial.rs

@@ -672,3 +672,66 @@ fn can_append_partial_paths() -> Result<(), PathResolutionError> {
 
     Ok(())
 }
+
+#[test]
+fn can_resolve_to_node() -> Result<(), PathResolutionError> {
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").expect("");
+
+    let jump_to_scope_node = StackGraph::jump_to_node();
+    let exported_scope = create_scope_node(&mut graph, file, true);
+    let baz_def = create_pop_scoped_symbol_node(&mut graph, file, "baz", false);
+
+    // resolved node ends up in precondition scope stack
+    {
+        let mut g = StackGraph::new();
+        g.add_from_graph(&graph).expect("");
+
+        let mut ps = PartialPaths::new();
+        let mut p =
+            create_partial_path_and_edges(&mut g, &mut ps, &[jump_to_scope_node]).expect("");
+
+        p.resolve_to_node(&g, &mut ps, exported_scope).expect("");
+        assert_eq!(
+            Some(exported_scope),
+            p.scope_stack_precondition.pop_front(&mut ps)
+        );
+    }
+
+    // precondition is fixed, and resolving fails
+    {
+        let mut g = StackGraph::new();
+        g.add_from_graph(&graph).expect("");
+
+        let mut ps = PartialPaths::new();
+        let mut p =
+            create_partial_path_and_edges(&mut g, &mut ps, &[jump_to_scope_node]).expect("");
+
+        p.eliminate_precondition_stack_variables(&mut ps);
+        p.resolve_to_node(&g, &mut ps, exported_scope)
+            .expect_err("");
+    }
+
+    // resolved node ends up in scoped symbol in precondition symbol stack
+    // resolving succeeds even though the scope stack is finite
+    {
+        let mut g = StackGraph::new();
+        g.add_from_graph(&graph).expect("");
+
+        let mut ps = PartialPaths::new();
+        let mut p = create_partial_path_and_edges(&mut g, &mut ps, &[baz_def, jump_to_scope_node])
+            .expect("");
+
+        p.eliminate_precondition_stack_variables(&mut ps);
+        p.resolve_to_node(&g, &mut ps, exported_scope).expect("");
+        assert_eq!(
+            Some(exported_scope),
+            p.symbol_stack_precondition
+                .pop_front(&mut ps)
+                .and_then(|s| s.scopes.into_option())
+                .and_then(|mut st| st.pop_front(&mut ps))
+        );
+    }
+
+    Ok(())
+}