Never extend or append without resolving, to prevent invalid paths being created

Author: Hendrik van Antwerpen

stack-graphs/src/partial.rs

@@ -2303,6 +2303,9 @@ impl PartialPath {
                 precedence: edge.precedence,
             },
         );
+
+        self.resolve(graph, partials)?;
+
         Ok(())
     }
 
@@ -2363,9 +2366,6 @@ impl PartialPath {
             if new_path.append(graph, partials, extension).is_err() {
                 continue;
             }
-            if new_path.resolve(graph, partials).is_err() {
-                continue;
-            }
             result.push(new_path);
         }
     }
@@ -2632,6 +2632,9 @@ impl Path {
             self.edges.push_back(paths, edge.into());
         }
         self.end_node = partial_path.end_node;
+
+        self.resolve(graph, paths)?;
+
         Ok(())
     }
 }
@@ -2755,6 +2758,9 @@ impl PartialPath {
             lhs.edges.push_back(partials, edge);
         }
         lhs.end_node = rhs.end_node;
+
+        lhs.resolve(graph, partials)?;
+
         Ok(())
     }
 }

stack-graphs/src/paths.rs

@@ -813,6 +813,9 @@ impl Path {
                 precedence: edge.precedence,
             },
         );
+
+        self.resolve(graph, paths)?;
+
         Ok(())
     }
 
@@ -860,9 +863,6 @@ impl Path {
             if new_path.append(graph, paths, extension).is_err() {
                 continue;
             }
-            if new_path.resolve(graph, paths).is_err() {
-                continue;
-            }
             result.push(new_path);
         }
     }

stack-graphs/src/stitching.rs

@@ -585,11 +585,6 @@ impl PathStitcher {
                 copious_debugging!("        is invalid: {:?}", err);
                 continue;
             }
-            #[cfg_attr(not(feature = "copious-debugging"), allow(unused_variables))]
-            if let Err(err) = new_path.resolve(graph, paths) {
-                copious_debugging!("        cannot resolve: {:?}", err);
-                continue;
-            }
             copious_debugging!("        is {}", new_path.display(graph, paths));
             self.next_iteration.push_back(new_path);
         }
@@ -875,14 +870,6 @@ impl ForwardPartialPathStitcher {
                     copious_debugging!("        is invalid: slips off of starting node");
                     continue;
                 }
-                if let Err(err) = new_partial_path.resolve(graph, partials) {
-                    copious_debugging!("        is invalid: cannot resolve: {:?}", err);
-                    continue;
-                }
-                if graph[new_partial_path.end_node].is_jump_to() {
-                    copious_debugging!("        is invalid: cannot resolve: ambiguous scope stack");
-                    continue;
-                }
             }
             copious_debugging!("        is {}", new_partial_path.display(graph, partials));
             self.next_iteration.push_back(new_partial_path);

stack-graphs/tests/it/partial.rs

@@ -571,6 +571,8 @@ fn can_concatenate_partial_paths() -> Result<(), PathResolutionError> {
     let mut graph = StackGraph::new();
     let file = graph.add_file("test").expect("");
 
+    let jump_to_scope_node = StackGraph::jump_to_node();
+
     let scope0_id = graph.new_node_id(file);
     let scope0 = graph.add_scope_node(scope0_id, false).unwrap();
 
@@ -739,5 +741,25 @@ fn can_concatenate_partial_paths() -> Result<(), PathResolutionError> {
         "<%1> ($1) [test(0) scope] -> [test(1) scope] <%1> ()",
     );
 
+    verify_not(
+        &graph,
+        &[scope0, drop_scopes, scope1],
+        &[scope1, jump_to_scope_node],
+    );
+
+    verify(
+        &graph,
+        &[baz_def, scope0],
+        &[scope0, jump_to_scope_node],
+        "<baz/($2),%1> ($1) [test(8) pop scoped baz] -> [jump to scope] <%1> ($2)",
+    );
+
+    verify(
+        &graph,
+        &[baz_ref, scope0],
+        &[scope0, jump_to_scope_node],
+        "<%1> ($1) [test(7) push scoped baz test(6)] -> [jump to scope] <baz/([test(6)],$1),%1> ($1)",
+    );
+
     Ok(())
 }