BE-581, BE-589: HashQL: Introduce pass::lower/pass::place pipeline facades and fix cached constructor closure bug

libs/@local/hashql/compiletest/src/pipeline.rs

@@ -31,12 +31,7 @@ use hashql_mir::{
     body::Body,
     context::MirContext,
     def::{DefId, DefIdSlice, DefIdVec},
-    pass::{
-        Changed, GlobalAnalysisPass as _, GlobalTransformPass as _, GlobalTransformState,
-        analysis::SizeEstimationAnalysis,
-        execution::{ExecutionAnalysis, ExecutionAnalysisResidual},
-        transform::{Inline, InlineConfig, PostInline, PreInline},
-    },
+    pass::{self, LowerConfig, execution::ExecutionAnalysisResidual},
     reify::ReifyContext,
 };
 use hashql_syntax_jexpr::span::Span;
@@ -189,9 +184,11 @@ impl<'heap> Pipeline<'heap> {
             bodies: &mut bodies,
             mir: &mut mir_context,
             hir: &hir_context,
+            scratch: &self.scratch,
         };
 
         let entry = tri!(hashql_mir::reify::from_hir(node, &mut reify_context));
+        self.scratch.reset();
 
         // drain the context, because we're going to re-create it
         self.diagnostics.extend(
@@ -218,24 +215,14 @@ impl<'heap> Pipeline<'heap> {
         bodies: &mut DefIdSlice<Body<'heap>>,
     ) -> Result<(), BoxedDiagnostic<'static, SpanId>> {
         let mut context = MirContext::new(&self.env, interner);
-        let mut state = GlobalTransformState::new_in(&*bodies, self.heap);
-
-        self.scratch.reset();
-
-        let mut pass = PreInline::new_in(&mut self.scratch);
-        let _: Changed = pass.run(&mut context, &mut state, bodies);
-        self.scratch.reset();
-
-        let mut pass = Inline::new_in(InlineConfig::default(), &mut self.scratch);
-        let _: Changed = pass.run(&mut context, &mut state, bodies);
-        self.scratch.reset();
 
-        let mut pass = PostInline::new_in(&mut self.scratch);
-        let _: Changed = pass.run(&mut context, &mut state, bodies);
-        self.scratch.reset();
-
-        let status = context.diagnostics.generalize().boxed().into_status(());
-        process_status(&mut self.diagnostics, status)?;
+        let result = pass::lower(
+            &mut context,
+            &mut self.scratch,
+            bodies,
+            &LowerConfig::default(),
+        );
+        process_status(&mut self.diagnostics, result)?;
 
         Ok(())
     }
@@ -262,20 +249,8 @@ impl<'heap> Pipeline<'heap> {
     > {
         let mut context = MirContext::new(&self.env, interner);
 
-        let mut pass = SizeEstimationAnalysis::new_in(&self.scratch);
-        pass.run(&mut context, bodies);
-        let footprints = pass.finish();
-        self.scratch.reset();
-
-        let pass = ExecutionAnalysis {
-            footprints: &footprints,
-            scratch: &mut self.scratch,
-        };
-        let analysis = pass.run_all_in(&mut context, bodies, self.heap);
-        self.scratch.reset();
-
-        let status = context.diagnostics.generalize().boxed().into_status(());
-        process_status(&mut self.diagnostics, status)?;
+        let status = pass::place(&mut context, &mut self.scratch, bodies);
+        let analysis = process_status(&mut self.diagnostics, status)?;
 
         Ok(analysis)
     }

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

@@ -122,7 +122,7 @@ impl Suite for EvalPostgres {
             &interner,
             &bodies,
             &analysis,
-            context.heap,
+            heap,
             &mut scratch,
         );
         scratch.reset();

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

@@ -38,7 +38,8 @@ impl Suite for MirPassAnalysisDataDependency {
 
         let mut buffer = Vec::new();
 
-        let (root, mut bodies) = mir_reify(heap, expr, &interner, &mut environment, diagnostics)?;
+        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);

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

@@ -49,7 +49,8 @@ pub(crate) fn mir_pass_transform_cfg_simplify<'heap>(
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
 ) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
-    let (root, mut bodies) = mir_reify(heap, expr, interner, environment, diagnostics)?;
+    let (root, mut bodies, mut scratch) =
+        mir_reify(heap, expr, interner, environment, diagnostics)?;
 
     render(heap, environment, root, &bodies);
 
@@ -59,7 +60,6 @@ pub(crate) fn mir_pass_transform_cfg_simplify<'heap>(
         interner,
         diagnostics: DiagnosticIssues::new(),
     };
-    let mut scratch = Scratch::new();
 
     let mut pass = CfgSimplify::new_in(&mut scratch);
     for body in bodies.as_mut_slice() {

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

@@ -168,7 +168,7 @@ pub(crate) fn mir_pass_transform_pre_inline<'heap>(
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
 ) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
-    let (root, mut bodies) = mir_reify(heap, expr, interner, environment, diagnostics)?;
+    let (root, mut bodies, _) = mir_reify(heap, expr, interner, environment, diagnostics)?;
 
     render.render(
         &mut RenderContext {

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

@@ -8,7 +8,7 @@ use std::{
 use error_stack::ReportSink;
 use hashql_ast::node::expr::Expr;
 use hashql_core::{
-    heap::Heap,
+    heap::{Heap, ResetAllocator as _, Scratch},
     id::IdVec,
     module::ModuleRegistry,
     pretty::Formatter,
@@ -32,7 +32,8 @@ pub(crate) fn mir_reify<'heap>(
     interner: &Interner<'heap>,
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
-) -> Result<(DefId, DefIdVec<Body<'heap>>), SuiteDiagnostic> {
+) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
+    let mut scratch = Scratch::new();
     let registry = ModuleRegistry::new(environment);
     let hir_interner = hashql_hir::intern::Interner::new(heap);
     let mut hir_context = HirContext::new(&hir_interner, &registry);
@@ -66,11 +67,13 @@ pub(crate) fn mir_reify<'heap>(
                 bodies: &mut bodies,
                 mir: &mut mir_context,
                 hir: &hir_context,
+                scratch: &scratch,
             },
         ),
     )?;
+    scratch.reset();
 
-    Ok((root, bodies))
+    Ok((root, bodies, scratch))
 }
 
 pub(crate) fn mir_format_text<'heap>(
@@ -208,7 +211,7 @@ impl Suite for MirReifySuite {
         let mut environment = Environment::new(heap);
         let interner = Interner::new(heap);
 
-        let (root, bodies) = mir_reify(heap, expr, &interner, &mut environment, diagnostics)?;
+        let (root, bodies, _) = mir_reify(heap, expr, &interner, &mut environment, diagnostics)?;
 
         let mut buffer = Vec::new();
         mir_format_text(heap, &environment, &mut buffer, root, &bodies);

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

@@ -50,6 +50,7 @@
 use alloc::alloc::Global;
 use core::{
     alloc::Allocator,
+    fmt,
     ops::{Index, IndexMut},
 };
 
@@ -213,7 +214,7 @@ impl<E> Edge<E> {
 /// }
 /// # else { unreachable!() }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct LinkedGraph<N, E, A: Allocator = Global> {
     /// All nodes in the graph, indexed by [`NodeId`].
     nodes: IdVec<NodeId, Node<N>, A>,
@@ -541,6 +542,17 @@ impl<N, E> Default for LinkedGraph<N, E> {
     }
 }
 
+impl<N: core::fmt::Debug, E: core::fmt::Debug, A: Allocator> core::fmt::Debug
+    for LinkedGraph<N, E, A>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("LinkedGraph")
+            .field("nodes", &self.nodes)
+            .field("edges", &self.edges)
+            .finish()
+    }
+}
+
 impl<N, E, A: Allocator> IndexMut<NodeId> for LinkedGraph<N, E, A> {
     fn index_mut(&mut self, index: NodeId) -> &mut Self::Output {
         &mut self.nodes[index]

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

@@ -60,12 +60,14 @@ impl<'heap> Operand<'heap> {
 }
 
 impl From<!> for Operand<'_> {
+    #[inline]
     fn from(value: !) -> Self {
         value
     }
 }
 
 impl From<Local> for Operand<'_> {
+    #[inline]
     fn from(local: Local) -> Self {
         Operand::Place(Place::local(local))
     }

libs/@local/hashql/mir/src/pass/analysis/data_dependency/mod.rs

@@ -104,6 +104,7 @@ impl DataDependencyAnalysis<'_> {
 }
 
 impl Default for DataDependencyAnalysis<'_> {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }

libs/@local/hashql/mir/src/pass/execution/cost/mod.rs

@@ -252,6 +252,7 @@ impl From<Cost> for ApproxCost {
 }
 
 impl From<InformationUnit> for ApproxCost {
+    #[inline]
     fn from(value: InformationUnit) -> Self {
         #[expect(clippy::cast_precision_loss)]
         Self(value.as_u32() as f32)

libs/@local/hashql/mir/src/pass/execution/island/graph/mod.rs

@@ -23,6 +23,7 @@ pub(crate) mod tests;
 use alloc::alloc::Global;
 use core::{
     alloc::Allocator,
+    fmt,
     ops::{Index, IndexMut},
 };
 
@@ -287,6 +288,16 @@ impl<A: Allocator> IslandGraph<A> {
     }
 }
 
+impl<A: Allocator> fmt::Debug for IslandGraph<A> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("IslandGraph")
+            .field("vertex", &self.vertex)
+            .field("inner", &self.inner)
+            .field("lookup", &self.lookup)
+            .finish()
+    }
+}
+
 impl<A: Allocator> DirectedGraph for IslandGraph<A> {
     type Edge<'this>
         = &'this Edge<IslandEdge>

libs/@local/hashql/mir/src/pass/execution/island/mod.rs

@@ -84,6 +84,7 @@ impl Island {
         self.members.is_empty()
     }
 
+    #[inline]
     #[must_use]
     pub const fn traversals(&self) -> TraversalPathBitSet {
         self.traversals
@@ -114,6 +115,7 @@ impl IslandPlacement<Global> {
 }
 
 impl Default for IslandPlacement<Global> {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }

libs/@local/hashql/mir/src/pass/execution/mod.rs

@@ -19,7 +19,7 @@ mod terminator_placement;
 pub mod traversal;
 mod vertex;
 
-use core::{alloc::Allocator, assert_matches};
+use core::{alloc::Allocator, assert_matches, fmt};
 
 use hashql_core::heap::{BumpAllocator, Heap};
 
@@ -57,6 +57,15 @@ pub struct ExecutionAnalysisResidual<A: Allocator> {
     pub islands: IslandGraph<A>,
 }
 
+impl<A: Allocator> core::fmt::Debug for ExecutionAnalysisResidual<A> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("ExecutionAnalysisResidual")
+            .field("assignment", &self.assignment)
+            .field("islands", &self.islands)
+            .finish()
+    }
+}
+
 pub struct ExecutionAnalysis<'ctx, 'heap, S: Allocator> {
     pub footprints: &'ctx DefIdSlice<BodyFootprint<&'heap Heap>>,
     pub scratch: S,

libs/@local/hashql/mir/src/pass/execution/splitting/mod.rs

@@ -401,6 +401,7 @@ impl<S: Allocator> BasicBlockSplitting<S> {
 }
 
 impl Default for BasicBlockSplitting<Global> {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }

libs/@local/hashql/mir/src/pass/execution/terminator_placement/mod.rs

@@ -201,6 +201,7 @@ impl TransMatrix {
 }
 
 impl Default for TransMatrix {
+    #[inline]
     fn default() -> Self {
         Self::new()
     }

libs/@local/hashql/mir/src/pass/execution/traversal/mod.rs

@@ -309,6 +309,7 @@ impl TraversalPathBitMap {
 }
 
 impl From<TraversalPathBitSet> for TraversalPathBitMap {
+    #[inline]
     fn from(value: TraversalPathBitSet) -> Self {
         let mut this = TraversalMapLattice.bottom();
         this[value.vertex()] = value;