Merge pull request #277 from github/add-debug-info-edges

Include edge debug information in visualization

Author: Hendrik van Antwerpen

languages/tree-sitter-stack-graphs-typescript/rust/util.rs

@@ -22,7 +22,7 @@ pub const PKG_M_NS: &str = "%PkgM";
 pub fn add_debug_name(graph: &mut StackGraph, node: Handle<Node>, name: &str) {
     let key = graph.add_string("name");
     let value = graph.add_string(name);
-    graph.debug_info_mut(node).add(key, value);
+    graph.node_debug_info_mut(node).add(key, value);
 }
 
 pub fn add_pop(

stack-graphs/src/graph.rs

@@ -1292,7 +1292,7 @@ pub struct Edge {
     pub precedence: i32,
 }
 
-struct OutgoingEdge {
+pub(crate) struct OutgoingEdge {
     sink: Handle<Node>,
     precedence: i32,
 }
@@ -1387,13 +1387,40 @@ pub struct DebugEntry {
 
 impl StackGraph {
     /// Returns debug information about the stack graph node.
-    pub fn debug_info(&self, node: Handle<Node>) -> Option<&DebugInfo> {
-        self.debug_info.get(node)
+    pub fn node_debug_info(&self, node: Handle<Node>) -> Option<&DebugInfo> {
+        self.node_debug_info.get(node)
     }
 
     /// Returns a mutable reference to the debug info about the stack graph node.
-    pub fn debug_info_mut(&mut self, node: Handle<Node>) -> &mut DebugInfo {
-        &mut self.debug_info[node]
+    pub fn node_debug_info_mut(&mut self, node: Handle<Node>) -> &mut DebugInfo {
+        &mut self.node_debug_info[node]
+    }
+
+    /// Returns debug information about the stack graph edge.
+    pub fn edge_debug_info(&self, source: Handle<Node>, sink: Handle<Node>) -> Option<&DebugInfo> {
+        self.edge_debug_info.get(source).and_then(|es| {
+            match es.binary_search_by_key(&sink, |e| e.0) {
+                Ok(idx) => Some(&es[idx].1),
+                Err(_) => None,
+            }
+        })
+    }
+
+    /// Returns a mutable reference to the debug info about the stack graph edge.
+    pub fn edge_debug_info_mut(
+        &mut self,
+        source: Handle<Node>,
+        sink: Handle<Node>,
+    ) -> &mut DebugInfo {
+        let es = &mut self.edge_debug_info[source];
+        let idx = match es.binary_search_by_key(&sink, |e| e.0) {
+            Ok(idx) => idx,
+            Err(idx) => {
+                es.insert(idx, (sink, DebugInfo::default()));
+                idx
+            }
+        };
+        &mut es[idx].1
     }
 }
 
@@ -1413,7 +1440,8 @@ pub struct StackGraph {
     pub(crate) source_info: SupplementalArena<Node, SourceInfo>,
     node_id_handles: NodeIDHandles,
     outgoing_edges: SupplementalArena<Node, SmallVec<[OutgoingEdge; 8]>>,
-    pub(crate) debug_info: SupplementalArena<Node, DebugInfo>,
+    pub(crate) node_debug_info: SupplementalArena<Node, DebugInfo>,
+    pub(crate) edge_debug_info: SupplementalArena<Node, SmallVec<[(Handle<Node>, DebugInfo); 8]>>,
 }
 
 impl StackGraph {
@@ -1546,8 +1574,8 @@ impl StackGraph {
                         definiens_span: source_info.definiens_span.clone(),
                     };
                 }
-                if let Some(debug_info) = other.debug_info(other_node) {
-                    *self.debug_info_mut(node) = DebugInfo {
+                if let Some(debug_info) = other.node_debug_info(other_node) {
+                    *self.node_debug_info_mut(node) = DebugInfo {
                         entries: debug_info
                             .entries
                             .iter()
@@ -1591,7 +1619,8 @@ impl Default for StackGraph {
             source_info: SupplementalArena::new(),
             node_id_handles: NodeIDHandles::new(),
             outgoing_edges: SupplementalArena::new(),
-            debug_info: SupplementalArena::new(),
+            node_debug_info: SupplementalArena::new(),
+            edge_debug_info: SupplementalArena::new(),
         }
     }
 }

stack-graphs/src/serde/graph.rs

@@ -12,6 +12,7 @@ use thiserror::Error;
 use crate::arena::Handle;
 
 use super::Filter;
+use super::ImplicationFilter;
 use super::NoFilter;
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
@@ -41,9 +42,10 @@ impl StackGraph {
     }
 
     pub fn from_graph_filter<'a>(graph: &crate::graph::StackGraph, filter: &'a dyn Filter) -> Self {
-        let files = graph.filter_files(filter);
-        let nodes = graph.filter_nodes(filter);
-        let edges = graph.filter_edges(filter);
+        let filter = ImplicationFilter(filter);
+        let files = graph.filter_files(&filter);
+        let nodes = graph.filter_nodes(&filter);
+        let edges = graph.filter_edges(&filter);
         Self {
             files,
             nodes,
@@ -146,7 +148,7 @@ impl StackGraph {
 
                 // load debug-info of each node
                 if let Some(debug_info) = node.debug_info() {
-                    *graph.debug_info_mut(handle) = debug_info.data.iter().fold(
+                    *graph.node_debug_info_mut(handle) = debug_info.data.iter().fold(
                         crate::graph::DebugInfo::default(),
                         |mut info, entry| {
                             let key = graph.add_string(&entry.key);
@@ -167,6 +169,7 @@ impl StackGraph {
             source,
             sink,
             precedence,
+            debug_info,
         } in &self.edges.data
         {
             let source_id = source.to_node_id(graph)?;
@@ -180,6 +183,19 @@ impl StackGraph {
                 .ok_or(Error::InvalidGlobalNodeID(sink.local_id))?;
 
             graph.add_edge(source_handle, sink_handle, *precedence);
+
+            // load debug-info of each node
+            if let Some(debug_info) = debug_info {
+                *graph.edge_debug_info_mut(source_handle, sink_handle) = debug_info
+                    .data
+                    .iter()
+                    .fold(crate::graph::DebugInfo::default(), |mut info, entry| {
+                        let key = graph.add_string(&entry.key);
+                        let value = graph.add_string(&entry.value);
+                        info.add(key, value);
+                        info
+                    });
+            }
         }
         Ok(())
     }
@@ -392,6 +408,8 @@ pub struct Edge {
     pub source: NodeID,
     pub sink: NodeID,
     pub precedence: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub debug_info: Option<DebugInfo>,
 }
 
 impl crate::graph::StackGraph {
@@ -430,12 +448,12 @@ impl crate::graph::StackGraph {
         })
     }
 
-    fn filter_debug_info<'a>(
+    fn filter_node_debug_info<'a>(
         &self,
         _filter: &'a dyn Filter,
         handle: Handle<crate::graph::Node>,
     ) -> Option<DebugInfo> {
-        self.debug_info(handle).map(|info| DebugInfo {
+        self.node_debug_info(handle).map(|info| DebugInfo {
             data: info
                 .iter()
                 .map(|entry| DebugEntry {
@@ -455,7 +473,7 @@ impl crate::graph::StackGraph {
                     let node = &self[handle];
                     let id = self.filter_node(filter, node.id());
                     let source_info = self.filter_source_info(filter, handle);
-                    let debug_info = self.filter_debug_info(filter, handle);
+                    let debug_info = self.filter_node_debug_info(filter, handle);
 
                     match node {
                         crate::graph::Node::DropScopes(_node) => Node::DropScopes {
@@ -525,10 +543,29 @@ impl crate::graph::StackGraph {
                             source: self.filter_node(filter, self[e.source].id()),
                             sink: self.filter_node(filter, self[e.sink].id()),
                             precedence: e.precedence,
+                            debug_info: self.filter_edge_debug_info(filter, e.source, e.sink),
                         })
                 })
                 .flatten()
                 .collect::<Vec<_>>(),
         }
     }
+
+    fn filter_edge_debug_info<'a>(
+        &self,
+        _filter: &'a dyn Filter,
+        source_handle: Handle<crate::graph::Node>,
+        sink_handle: Handle<crate::graph::Node>,
+    ) -> Option<DebugInfo> {
+        self.edge_debug_info(source_handle, sink_handle)
+            .map(|info| DebugInfo {
+                data: info
+                    .iter()
+                    .map(|entry| DebugEntry {
+                        key: self[entry.key].to_owned(),
+                        value: self[entry.value].to_owned(),
+                    })
+                    .collect(),
+            })
+    }
 }

stack-graphs/src/visualization.rs

@@ -36,7 +36,7 @@ impl StackGraph {
         filter: &dyn Filter,
     ) -> Result<String, Error> {
         let filter = VisualizationFilter(filter);
-        let graph = serde_json::to_string(&self.to_serializable())?;
+        let graph = serde_json::to_string(&self.to_serializable_filter(&filter))?;
         let paths = serde_json::to_string(&db.to_serializable_filter(self, partials, &filter))?;
         let html = format!(
             r#"

stack-graphs/tests/it/serde.rs

@@ -68,6 +68,7 @@ fn serde_json_stack_graph() {
                     local_id: 0,
                 },
                 precedence: 0,
+                debug_info: Some(serde::DebugInfo { data: vec![] }),
             }],
         },
     };
@@ -77,6 +78,7 @@ fn serde_json_stack_graph() {
         {
             "edges" : [
                 {
+                    "debug_info" : [],
                     "precedence" : 0,
                     "sink" : {
                         "file" : "index.ts",
@@ -320,7 +322,7 @@ fn can_load_serialized_stack_graph() {
         .find(|handle| matches!(sg[*handle], graph::Node::Scope(..)))
         .unwrap();
     assert!(sg.source_info(handle).is_some());
-    assert!(sg.debug_info(handle).is_some());
+    assert!(sg.node_debug_info(handle).is_some());
 }
 
 #[test]
@@ -376,6 +378,12 @@ fn can_serialize_graph() {
                     }
                 },
                 {
+                    "debug_info" : [
+                        {
+                            "key" : "dsl_position",
+                            "value" : "line 23 column 4"
+                        }
+                    ],
                     "precedence" : 0,
                     "sink" : {
                         "local_id" : 1

stack-graphs/tests/it/test_graphs/simple.rs

@@ -112,18 +112,22 @@ pub fn new() -> StackGraph {
     let str_lexical_scope = graph.add_string("lexical_scope");
     let str_pos_one = graph.add_string("line 31 column 20");
     let str_pos_two = graph.add_string("line 8 column 11");
+    let str_pos_three = graph.add_string("line 23 column 4");
     graph
-        .debug_info_mut(scope_x)
+        .node_debug_info_mut(scope_x)
         .add(str_dsl_var, str_arg_scope);
     graph
-        .debug_info_mut(scope_x)
+        .node_debug_info_mut(scope_x)
         .add(str_dsl_position, str_pos_one);
     graph
-        .debug_info_mut(scope)
+        .node_debug_info_mut(scope)
         .add(str_dsl_var, str_lexical_scope);
     graph
-        .debug_info_mut(scope)
+        .node_debug_info_mut(scope)
         .add(str_dsl_position, str_pos_two);
+    graph
+        .edge_debug_info_mut(scope, root)
+        .add(str_dsl_position, str_pos_three);
 
     graph
 }

tree-sitter-stack-graphs/src/lib.rs

@@ -329,6 +329,7 @@ use std::time::Instant;
 use thiserror::Error;
 use tree_sitter::Parser;
 use tree_sitter_graph::functions::Functions;
+use tree_sitter_graph::graph::Edge;
 use tree_sitter_graph::graph::Graph;
 use tree_sitter_graph::graph::GraphNode;
 use tree_sitter_graph::graph::GraphNodeRef;
@@ -881,7 +882,7 @@ impl<'a> Builder<'a> {
                 NodeType::Scope => self.load_scope(node_ref)?,
             };
             self.load_span(node_ref, handle)?;
-            self.load_debug_info(node_ref, handle)?;
+            self.load_node_debug_info(node_ref, handle)?;
         }
 
         for node in self.stack_graph.nodes_for_file(self.file) {
@@ -906,6 +907,12 @@ impl<'a> Builder<'a> {
                 let sink_handle = self.stack_graph.node_for_id(sink_node_id).unwrap();
                 self.stack_graph
                     .add_edge(source_handle, sink_handle, precedence);
+                Self::load_edge_debug_info(
+                    &mut self.stack_graph,
+                    source_handle,
+                    sink_handle,
+                    edge,
+                )?;
             }
         }
 
@@ -1105,7 +1112,7 @@ impl<'a> Builder<'a> {
         Ok(())
     }
 
-    fn load_debug_info(
+    fn load_node_debug_info(
         &mut self,
         node_ref: GraphNodeRef,
         node_handle: Handle<Node>,
@@ -1122,7 +1129,32 @@ impl<'a> Builder<'a> {
                     .stack_graph
                     .add_string(&name[DEBUG_ATTR_PREFIX.len()..]);
                 let value = self.stack_graph.add_string(&value);
-                self.stack_graph.debug_info_mut(node_handle).add(key, value);
+                self.stack_graph
+                    .node_debug_info_mut(node_handle)
+                    .add(key, value);
+            }
+        }
+        Ok(())
+    }
+
+    fn load_edge_debug_info(
+        stack_graph: &mut StackGraph,
+        source_handle: Handle<Node>,
+        sink_handle: Handle<Node>,
+        edge: &Edge,
+    ) -> Result<(), BuildError> {
+        for (name, value) in edge.attributes.iter() {
+            let name = name.to_string();
+            if name.starts_with(DEBUG_ATTR_PREFIX) {
+                let value = match value {
+                    Value::String(value) => value.clone(),
+                    value => value.to_string(),
+                };
+                let key = stack_graph.add_string(&name[DEBUG_ATTR_PREFIX.len()..]);
+                let value = stack_graph.add_string(&value);
+                stack_graph
+                    .edge_debug_info_mut(source_handle, sink_handle)
+                    .add(key, value);
             }
         }
         Ok(())