render to graphviz dot

Author: jdonszelmann

scopegraphs-lib/Cargo.toml

@@ -11,6 +11,9 @@ description = "A port of [scopegraphs](https://pl.ewi.tudelft.nl/research/projec
 
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = []
+dot = ["dep:dot"]
 
 [dependencies]
 log = "0.4.20"
@@ -21,6 +24,7 @@ scopegraphs-regular-expressions = {path = "../scopegraphs-regular-expressions",
 scopegraphs-macros = {path = "../scopegraphs-macros", version = "0.1.0"}
 futures = "0.3.30"
 bumpalo = "3.14.0"
+dot = { version = "0.1.4", optional = true }
 
 [dev-dependencies]
 scopegraphs = {path = "../scopegraphs"}

scopegraphs-lib/src/lib.rs

@@ -9,3 +9,6 @@ pub mod storage;
 pub use label::Label;
 pub use scopegraph::*;
 pub use scopegraphs_macros;
+
+#[cfg(feature = "dot")]
+pub mod render;

scopegraphs-lib/src/render.rs

@@ -0,0 +1,111 @@
+use crate::completeness::Completeness;
+use crate::{Scope, ScopeGraph};
+use dot::LabelText::LabelStr;
+use dot::{Edges, Id, LabelText, Nodes};
+use std::borrow::Cow;
+use std::fmt::Debug;
+use std::fs::File;
+use std::io;
+use std::io::Write;
+use std::path::Path;
+
+pub trait RenderScopeData {
+    /// Renders a scope (or probably rather, the data in a scope).
+    /// Can return None if there's no data to render.
+    fn render(&self) -> Option<String>;
+
+    /// Returns whether this scope is a definition of some variable
+    ///
+    /// Defaults to whether the outcome of [`render`](RenderScopeData::render) is Some,
+    /// because often non-definition scopes have no data associated with them.
+    fn definition(&self) -> bool {
+        self.render().is_some()
+    }
+}
+
+impl<LABEL: Clone + Debug, DATA: RenderScopeData + Clone, CMPL: Completeness<LABEL, DATA>>
+    ScopeGraph<'_, LABEL, DATA, CMPL>
+{
+    pub fn render<W: Write>(&self, output: &mut W, name: &str) -> io::Result<()> {
+        dot::render(&(self, name), output)
+    }
+
+    pub fn render_to(&self, path: impl AsRef<Path>) -> io::Result<()> {
+        let path = path.as_ref();
+        let mut w = File::create(path)?;
+        let name = path
+            .file_stem()
+            .expect("path must have filename for File::create to work")
+            .to_string_lossy();
+        self.render(&mut w, &name)
+    }
+}
+
+impl<'a, LABEL: Clone + Debug, DATA: Clone + RenderScopeData, CMPL: Completeness<LABEL, DATA>>
+    dot::Labeller<'a, Scope, (Scope, LABEL, Scope)> for (&ScopeGraph<'_, LABEL, DATA, CMPL>, &str)
+{
+    fn graph_id(&'a self) -> Id<'a> {
+        Id::new(self.1).unwrap()
+    }
+
+    fn node_id(&'a self, n: &Scope) -> Id<'a> {
+        Id::new(format!("s{}", n.0)).unwrap()
+    }
+
+    fn node_label(&self, n: &Scope) -> LabelText {
+        let data = self.0.get_data(*n);
+        LabelText::label(data.render().unwrap_or_else(|| format!("scope {}", n.0)))
+    }
+    fn edge_label(&self, edge: &(Scope, LABEL, Scope)) -> LabelText {
+        LabelText::label(format!("{:?}", edge.1))
+    }
+
+    fn node_shape(&'a self, node: &Scope) -> Option<LabelText<'a>> {
+        let data = self.0.get_data(*node);
+        if data.definition() {
+            Some(LabelStr(Cow::Borrowed("box")))
+        } else {
+            Some(LabelStr(Cow::Borrowed("circle")))
+        }
+    }
+}
+
+impl<'a, LABEL: Clone, DATA: Clone, CMPL> dot::GraphWalk<'a, Scope, (Scope, LABEL, Scope)>
+    for (&ScopeGraph<'_, LABEL, DATA, CMPL>, &str)
+{
+    fn nodes(&'a self) -> Nodes<'a, Scope> {
+        (0..self.0.inner_scope_graph.data.borrow().len())
+            .map(Scope)
+            .collect()
+    }
+
+    fn edges(&'a self) -> Edges<'a, (Scope, LABEL, Scope)> {
+        self.0
+            .inner_scope_graph
+            .edges
+            .borrow()
+            .iter()
+            .enumerate()
+            .flat_map(|(scope, edges)| {
+                (*edges)
+                    .borrow()
+                    .iter()
+                    .flat_map(|(lbl, edges_with_lbl)| {
+                        edges_with_lbl
+                            .iter()
+                            .map(|edge| (Scope(scope), lbl.clone(), *edge))
+                            .collect::<Vec<_>>()
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect()
+    }
+
+    fn source(&'a self, edge: &(Scope, LABEL, Scope)) -> Scope {
+        edge.0
+    }
+
+    fn target(&'a self, edge: &(Scope, LABEL, Scope)) -> Scope {
+        edge.2
+    }
+}

scopegraphs-lib/src/scopegraph.rs

@@ -23,10 +23,10 @@ impl Debug for Scope {
 
 #[derive(Debug)]
 pub struct InnerScopeGraph<'sg, LABEL, DATA> {
-    storage: &'sg Storage,
+    pub(crate) storage: &'sg Storage,
     #[allow(clippy::type_complexity)]
-    edges: RefCell<Vec<&'sg RefCell<HashMap<LABEL, HashSet<Scope>>>>>, // FIXME: BTreeMap? Vectors? Whatever?
-    data: RefCell<Vec<&'sg DATA>>,
+    pub(crate) edges: RefCell<Vec<&'sg RefCell<HashMap<LABEL, HashSet<Scope>>>>>, // FIXME: BTreeMap? Vectors? Whatever?
+    pub(crate) data: RefCell<Vec<&'sg DATA>>,
 }
 
 impl<'sg, LABEL, DATA> InnerScopeGraph<'sg, LABEL, DATA> {

scopegraphs/Cargo.toml

@@ -19,5 +19,5 @@ scopegraphs-regular-expressions = {path="../scopegraphs-regular-expressions", ve
 
 [features]
 default = ["dot", "dynamic-regex"]
-dot = ["scopegraphs-regular-expressions/dot", "scopegraphs-macros/dot"]
+dot = ["scopegraphs-regular-expressions/dot", "scopegraphs-macros/dot", "scopegraphs-lib/dot"]
 dynamic-regex = ["scopegraphs-regular-expressions/dynamic"]