feat: demangle symbols and improve graph output

Add GRAPH_UNMANGLE support to demangle symbol names in dot/d2 output,
separate display names from node identity so demangled names render
correctly, sort external function nodes for deterministic output, fix
double-escaping of newlines in D2 container labels, and wire UNMANGLE
and SKIPLANGSTART env vars through Make graph targets.

Author: cds-amal

Makefile

@@ -89,6 +89,10 @@ OUTDIR_SVG=output-svg
 OUTDIR_PNG=output-png
 OUTDIR_D2=output-d2
 
+# Pass UNMANGLE=1 to demangle symbol names in graph output.
+# Pass SKIPLANGSTART=1 to filter out std::rt::lang_start items.
+GRAPH_ENV := $(if $(UNMANGLE),GRAPH_UNMANGLE=1) $(if $(SKIPLANGSTART),SKIP_LANG_START=1)
+
 clean-graphs:
 	@rm -rf $(OUTDIR_DOT) $(OUTDIR_SVG) $(OUTDIR_PNG) $(OUTDIR_D2)
 
@@ -105,7 +109,7 @@ dot:
 	@for rs in $(TESTDIR)/*.rs; do \
 		name=$$(basename $$rs .rs); \
 		echo "Generating $$name.smir.dot"; \
-		cargo run --release -- --dot -Zno-codegen $$rs 2>/dev/null; \
+		$(GRAPH_ENV) cargo run --release -- --dot -Zno-codegen $$rs 2>/dev/null; \
 		mv $$name.smir.dot $(OUTDIR_DOT)/ 2>/dev/null || true; \
 	done
 
@@ -130,6 +134,6 @@ d2:
 	@for rs in $(TESTDIR)/*.rs; do \
 		name=$$(basename $$rs .rs); \
 		echo "Generating $$name.smir.d2"; \
-		cargo run --release -- --d2 -Zno-codegen $$rs 2>/dev/null; \
+		$(GRAPH_ENV) cargo run --release -- --d2 -Zno-codegen $$rs 2>/dev/null; \
 		mv $$name.smir.d2 $(OUTDIR_D2)/ 2>/dev/null || true; \
 	done

src/compat/mod.rs

@@ -25,6 +25,7 @@
 //! `DefId`, etc.) without requiring them to know which rustc crate the
 //! type actually lives in.
 
+pub extern crate rustc_demangle;
 pub extern crate rustc_middle;
 pub extern crate rustc_monomorphize;
 pub extern crate rustc_session;

src/mk_graph/context.rs

@@ -11,6 +11,8 @@ use stable_mir::ty::{ConstantKind, IndexedVal, MirConst, Ty};
 
 use crate::printer::SmirJson;
 
+use crate::compat::rustc_demangle::demangle;
+
 use super::index::{AllocIndex, LayoutInfo, TypeEntry, TypeIndex, TypeKind};
 use super::util::{function_string, short_fn_name, GraphLabelString};
 
@@ -23,25 +25,50 @@ pub struct GraphContext {
     pub allocs: AllocIndex,
     pub types: TypeIndex,
     pub functions: HashMap<Ty, String>,
+    /// When `GRAPH_UNMANGLE=1`, maps mangled symbol names to demangled
+    /// display names. Empty otherwise. Renderers should call
+    /// `display_name()` for labels rather than using `functions` values
+    /// directly.
+    display_names: HashMap<String, String>,
 }
 
 impl GraphContext {
     pub fn from_smir(smir: &SmirJson) -> Self {
         let types = TypeIndex::from_types(&smir.types);
         let allocs = AllocIndex::from_alloc_infos(&smir.allocs, &types);
+        let unmangle = std::env::var("GRAPH_UNMANGLE").is_ok();
         let functions: HashMap<Ty, String> = smir
             .functions
             .iter()
             .map(|(k, v)| (k.0, function_string(v.clone())))
             .collect();
+        let display_names: HashMap<String, String> = if unmangle {
+            functions
+                .values()
+                .map(|name| (name.clone(), demangle(name).to_string()))
+                .collect()
+        } else {
+            HashMap::new()
+        };
 
         Self {
             allocs,
             types,
             functions,
+            display_names,
         }
     }
 
+    /// Return the display-friendly name for a symbol. When
+    /// `GRAPH_UNMANGLE=1` is set this is the demangled form;
+    /// otherwise it's the original (mangled) name.
+    pub fn display_name<'a>(&'a self, name: &'a str) -> &'a str {
+        self.display_names
+            .get(name)
+            .map(|s| s.as_str())
+            .unwrap_or(name)
+    }
+
     /// Render a constant operand with alloc information
     pub fn render_const(&self, const_: &MirConst) -> String {
         let ty = const_.ty();
@@ -78,7 +105,7 @@ impl GraphContext {
                 // Function pointers, unit type, etc.
                 if ty.kind().is_fn() {
                     if let Some(name) = self.functions.get(&ty) {
-                        format!("const fn {}", short_fn_name(name))
+                        format!("const fn {}", short_fn_name(self.display_name(name)))
                     } else {
                         format!("const {}", ty_name)
                     }
@@ -240,7 +267,7 @@ impl GraphContext {
             } => {
                 let fn_name = self
                     .resolve_call_target(func)
-                    .map(|n| short_fn_name(&n))
+                    .map(|n| short_fn_name(self.display_name(&n)))
                     .unwrap_or_else(|| "?".to_string());
                 let arg_str = args
                     .iter()

src/mk_graph/output/d2.rs

@@ -66,7 +66,7 @@ fn render_d2_function(
     out: &mut String,
 ) {
     let fn_id = short_name(name);
-    let display_name = escape_d2(&name_lines(name));
+    let display_name = name_lines(&escape_d2(name));
 
     // Function container
     out.push_str(&format!("{}: {{\n", fn_id));
@@ -131,7 +131,8 @@ fn render_d2_call_edges(
         }
 
         let target_id = short_name(&callee_name);
-        out.push_str(&format!("{}: \"{}\"\n", target_id, escape_d2(&callee_name)));
+        let display = ctx.display_name(&callee_name);
+        out.push_str(&format!("{}: \"{}\"\n", target_id, escape_d2(display)));
         out.push_str(&format!("{}.style.fill: \"#ffe0e0\"\n", target_id));
         out.push_str(&format!("{}.bb{} -> {}: call\n", fn_id, idx, target_id));
     }

src/mk_graph/output/dot.rs

@@ -57,13 +57,17 @@ impl SmirJson {
             }
 
             // first create all nodes for functions not in the items list
-            for f in ctx.functions.values() {
-                if !item_names.contains(f) {
-                    graph
-                        .node_named(block_name(f, 0))
-                        .set_label(&name_lines(f))
-                        .set_color(Color::Red);
-                }
+            let mut external_fns: Vec<&String> = ctx
+                .functions
+                .values()
+                .filter(|f| !item_names.contains(*f))
+                .collect();
+            external_fns.sort();
+            for f in external_fns {
+                graph
+                    .node_named(block_name(f, 0))
+                    .set_label(&name_lines(ctx.display_name(f)))
+                    .set_color(Color::Red);
             }
 
             for item in self.items {