BE-209: HashQL: Implement data dependency analysis for MIR (#8158)

Author: indietyp

libs/@local/hashql/compiletest/src/suite/mir_pass_analysis_data_dependency.rs

@@ -0,0 +1,68 @@
+use std::io::Write as _;
+
+use hashql_ast::node::expr::Expr;
+use hashql_core::r#type::environment::Environment;
+use hashql_diagnostics::DiagnosticIssues;
+use hashql_mir::{
+    context::MirContext,
+    intern::Interner,
+    pass::{Pass as _, analysis::DataDependencyAnalysis},
+};
+
+use super::{RunContext, Suite, SuiteDiagnostic};
+use crate::suite::{
+    common::{Header, process_issues},
+    mir_reify::{mir_format_text, mir_reify},
+};
+
+pub(crate) struct MirPassAnalysisDataDependency;
+
+impl Suite for MirPassAnalysisDataDependency {
+    fn name(&self) -> &'static str {
+        "mir/pass/analysis/data-dependency"
+    }
+
+    fn run<'heap>(
+        &self,
+        RunContext {
+            heap, diagnostics, ..
+        }: RunContext<'_, 'heap>,
+        expr: Expr<'heap>,
+    ) -> Result<String, SuiteDiagnostic> {
+        let mut environment = Environment::new(heap);
+        let interner = Interner::new(heap);
+
+        let mut buffer = Vec::new();
+
+        let (root, mut bodies) = mir_reify(heap, expr, &interner, &mut environment, diagnostics)?;
+
+        writeln!(buffer, "{}\n", Header::new("MIR")).expect("should be able to write to buffer");
+        mir_format_text(heap, &environment, &mut buffer, root, &bodies);
+
+        let mut context = MirContext {
+            heap,
+            env: &environment,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        };
+
+        let body = &mut bodies[root];
+        let mut analysis = DataDependencyAnalysis::new();
+        analysis.run(&mut context, body);
+        let graph = analysis.finish();
+        let transient = graph.transient(&interner);
+
+        let _ = writeln!(
+            buffer,
+            "\n{}\n\n{}\n\n{}\n\n{}",
+            Header::new("Data Dependency Graph"),
+            graph,
+            Header::new("Transient Data Dependency Graph"),
+            transient,
+        );
+
+        process_issues(diagnostics, context.diagnostics)?;
+
+        Ok(String::from_utf8_lossy_owned(buffer))
+    }
+}

libs/@local/hashql/compiletest/src/suite/mod.rs

@@ -20,6 +20,7 @@ mod hir_lower_normalization;
 mod hir_lower_specialization;
 mod hir_lower_thunking;
 mod hir_reify;
+mod mir_pass_analysis_data_dependency;
 mod mir_pass_transform_cfg_simplify;
 mod mir_reify;
 mod parse_syntax_dump;
@@ -50,6 +51,7 @@ use self::{
     hir_lower_normalization::HirLowerNormalizationSuite,
     hir_lower_specialization::HirLowerSpecializationSuite,
     hir_lower_thunking::HirLowerThunkingSuite, hir_reify::HirReifySuite,
+    mir_pass_analysis_data_dependency::MirPassAnalysisDataDependency,
     mir_pass_transform_cfg_simplify::MirPassTransformCfgSimplify, mir_reify::MirReifySuite,
     parse_syntax_dump::ParseSyntaxDumpSuite,
 };
@@ -144,6 +146,7 @@ const SUITES: &[&dyn Suite] = &[
     &HirLowerTypeInferenceIntrinsicsSuite,
     &HirLowerTypeInferenceSuite,
     &HirReifySuite,
+    &MirPassAnalysisDataDependency,
     &MirPassTransformCfgSimplify,
     &MirReifySuite,
     &ParseSyntaxDumpSuite,

libs/@local/hashql/core/src/graph/linked.rs

@@ -48,12 +48,12 @@
 //! ```
 
 use alloc::alloc::Global;
-use core::alloc::Allocator;
+use core::{alloc::Allocator, ops::Index};
 
 use super::{
     DIRECTIONS, DirectedGraph, Direction, EdgeId, NodeId, Predecessors, Successors, Traverse,
 };
-use crate::id::{HasId, IdSlice, IdVec};
+use crate::id::{HasId, Id, IdSlice, IdVec};
 
 /// Sentinel value indicating "no edge" in linked lists.
 ///
@@ -69,6 +69,7 @@ const TOMBSTONE: EdgeId = EdgeId(usize::MAX);
 /// - Two linked list heads (outgoing and incoming edges)
 ///
 /// The `edges` array stores the head of each linked list, indexed by [`Direction`].
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct Node<N> {
     /// Unique identifier for this node.
     id: NodeId,
@@ -102,6 +103,7 @@ impl<N> HasId for Node<N> {
 /// The edge participates in two separate linked lists simultaneously:
 /// 1. The source node's outgoing edge list
 /// 2. The target node's incoming edge list
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct Edge<E> {
     /// Unique identifier for this edge.
     id: EdgeId,
@@ -207,6 +209,7 @@ impl<E> Edge<E> {
 /// }
 /// # else { unreachable!() }
 /// ```
+#[derive(Debug, Clone)]
 pub struct LinkedGraph<N, E, A: Allocator = Global> {
     /// All nodes in the graph, indexed by [`NodeId`].
     nodes: IdVec<NodeId, Node<N>, A>,
@@ -284,6 +287,49 @@ impl<N, E, A: Allocator> LinkedGraph<N, E, A> {
         })
     }
 
+    /// Populates the graph with nodes derived from an existing indexed collection.
+    ///
+    /// For each element in `domain`, calls `data` to produce the node data and adds a
+    /// corresponding node to the graph. The resulting [`NodeId`]s will have the same
+    /// numeric values as the source collection's indices, enabling direct ID translation
+    /// between the domain and the graph.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the graph already contains nodes. This method is intended for initial
+    /// population only.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use hashql_core::graph::LinkedGraph;
+    /// # use hashql_core::id::{Id, IdVec};
+    /// #
+    /// # hashql_core::id::newtype!(struct MyId(usize is 0..=usize::MAX));
+    /// #
+    /// let mut items: IdVec<MyId, &str> = IdVec::new();
+    /// items.push("first");
+    /// items.push("second");
+    ///
+    /// let mut graph: LinkedGraph<&str, ()> = LinkedGraph::new();
+    /// graph.derive(&items, |_id, &value| value);
+    ///
+    /// // Node 0 corresponds to items[0], etc.
+    /// assert_eq!(graph.nodes().len(), 2);
+    /// ```
+    pub fn derive<I, T>(&mut self, domain: &IdSlice<I, T>, mut data: impl FnMut(I, &T) -> N)
+    where
+        I: Id,
+    {
+        assert!(self.nodes.is_empty());
+
+        self.nodes.raw.reserve(domain.len());
+
+        for (id, item) in domain.iter_enumerated() {
+            self.add_node(data(id, item));
+        }
+    }
+
     /// Returns a reference to the node with the given identifier.
     ///
     /// Returns [`None`] if no node exists with that identifier.
@@ -378,6 +424,14 @@ impl<N, E, A: Allocator> LinkedGraph<N, E, A> {
         self.edges.as_slice()
     }
 
+    /// Removes all edges from the graph while preserving nodes.
+    pub fn clear_edges(&mut self) {
+        self.edges.clear();
+        for node in self.nodes.iter_mut() {
+            node.edges = [TOMBSTONE; DIRECTIONS];
+        }
+    }
+
     /// Returns an iterator over edges incident to a node in the given direction.
     ///
     /// For [`Direction::Outgoing`], iterates edges where `node` is the source.
@@ -459,6 +513,12 @@ impl<N, E, A: Allocator> LinkedGraph<N, E, A> {
     pub fn outgoing_edges(&self, node: NodeId) -> IncidentEdges<'_, N, E, A> {
         IncidentEdges::new(self, Direction::Outgoing, node)
     }
+
+    /// Removes all nodes and edges from the graph.
+    pub fn clear(&mut self) {
+        self.nodes.clear();
+        self.edges.clear();
+    }
 }
 
 impl<N, E> Default for LinkedGraph<N, E> {
@@ -467,6 +527,22 @@ impl<N, E> Default for LinkedGraph<N, E> {
     }
 }
 
+impl<N, E, A: Allocator> Index<NodeId> for LinkedGraph<N, E, A> {
+    type Output = Node<N>;
+
+    fn index(&self, index: NodeId) -> &Self::Output {
+        &self.nodes[index]
+    }
+}
+
+impl<N, E, A: Allocator> Index<EdgeId> for LinkedGraph<N, E, A> {
+    type Output = Edge<E>;
+
+    fn index(&self, index: EdgeId) -> &Self::Output {
+        &self.edges[index]
+    }
+}
+
 impl<N, E, A: Allocator> DirectedGraph for LinkedGraph<N, E, A> {
     type Edge<'this>
         = &'this Edge<E>

libs/@local/hashql/mir/src/body/place.rs

@@ -3,7 +3,7 @@
 //! Places represent storage locations in the MIR, including local variables and complex paths
 //! through data structures. Projections allow accessing nested data within structured types.
 
-use core::alloc::Allocator;
+use core::{alloc::Allocator, fmt};
 
 use hashql_core::{id, intern::Interned, symbol::Symbol, r#type::TypeId};
 
@@ -400,3 +400,13 @@ pub enum ProjectionKind<'heap> {
     /// [`Local`] contains the index value that determines which element to access.
     Index(Local),
 }
+
+impl fmt::Display for ProjectionKind<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ProjectionKind::Field(index) => write!(fmt, ".{index}"),
+            ProjectionKind::FieldByName(name) => write!(fmt, ".{name}"),
+            ProjectionKind::Index(index) => write!(fmt, "[%{index}]"),
+        }
+    }
+}