BE-197: Implement MIR inline pass for HashQL

.claude/skills/testing-hashql/references/mir-builder-guide.md

@@ -56,13 +56,22 @@ body!(interner, env; <source> @ <id> / <arity> -> <return_type> {
 
 | Component | Description | Example |
 | --------- | ----------- | ------- |
-| `<source>` | Body source type | `fn` (closure) or `thunk` |
+| `<source>` | Body source type | `fn`, `thunk`, `[ctor expr]`, `intrinsic` |
 | `<id>` | DefId (literal or variable) | `0`, `42`, `my_def_id` |
 | `<arity>` | Number of function arguments | `0`, `1`, `2` |
 | `<return_type>` | Return type | `Int`, `Bool`, `(Int, Bool)` |
 
 The `<id>` can be a numeric literal (`0`, `1`, `42`) or a variable identifier (`callee_id`, `my_def_id`). When using a variable, it must be a `DefId` in scope.
 
+**Source types:**
+
+| Syntax | Maps to | Use case |
+| ------ | ------- | -------- |
+| `fn` | `Source::Closure` | Regular closures/functions |
+| `thunk` | `Source::Thunk` | Thunk bodies (zero-arg delayed computations) |
+| `[ctor sym::path]` | `Source::Ctor(sym)` | Constructor bodies (always inlined) |
+| `intrinsic` | `Source::Intrinsic` | Intrinsic bodies (never inlined) |
+
 ### Types
 
 | Syntax | Description | Example |

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

@@ -2,7 +2,7 @@ use std::io::Write as _;
 
 use hashql_ast::node::expr::Expr;
 use hashql_core::{
-    heap::{Heap, Scratch},
+    heap::{Heap, ResetAllocator as _, Scratch},
     id::IdVec,
     r#type::environment::Environment,
 };
@@ -52,6 +52,7 @@ pub(crate) fn mir_pass_transform_administrative_reduction<'heap>(
         &mut GlobalTransformState::new(&mut changed),
         &mut bodies,
     );
+    scratch.reset();
 
     process_issues(diagnostics, context.diagnostics)?;
     Ok((root, bodies, scratch))

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

@@ -5,7 +5,7 @@ use std::{
 
 use hashql_ast::node::expr::Expr;
 use hashql_core::{
-    heap::{Heap, Scratch},
+    heap::{Heap, ResetAllocator as _, Scratch},
     r#type::environment::Environment,
 };
 use hashql_diagnostics::DiagnosticIssues;
@@ -65,6 +65,7 @@ pub(crate) fn mir_pass_transform_cfg_simplify<'heap>(
     for body in bodies.as_mut_slice() {
         let _: Changed = pass.run(&mut context, body);
     }
+    scratch.reset();
 
     process_issues(diagnostics, context.diagnostics)?;
 

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

@@ -2,7 +2,7 @@ use std::io::Write as _;
 
 use hashql_ast::node::expr::Expr;
 use hashql_core::{
-    heap::{Heap, Scratch},
+    heap::{Heap, ResetAllocator as _, Scratch},
     r#type::environment::Environment,
 };
 use hashql_diagnostics::DiagnosticIssues;
@@ -46,6 +46,7 @@ pub(crate) fn mir_pass_transform_forward_substitution<'heap>(
     for body in bodies.as_mut_slice() {
         let _: Changed = pass.run(&mut context, body);
     }
+    scratch.reset();
 
     process_issues(diagnostics, context.diagnostics)?;
     Ok((root, bodies, scratch))

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

@@ -0,0 +1,180 @@
+use std::io::Write as _;
+
+use hashql_ast::node::expr::Expr;
+use hashql_core::{
+    heap::{Heap, ResetAllocator as _, Scratch},
+    r#type::environment::Environment,
+};
+use hashql_diagnostics::DiagnosticIssues;
+use hashql_mir::{
+    body::Body,
+    context::MirContext,
+    def::{DefId, DefIdVec},
+    intern::Interner,
+    pass::{
+        Changed, GlobalTransformPass as _, GlobalTransformState,
+        transform::{Inline, InlineConfig},
+    },
+};
+
+use super::{
+    RunContext, Suite, SuiteDiagnostic,
+    common::process_issues,
+    mir_pass_transform_pre_inlining::{
+        MirRenderer, RenderContext, Stage, mir_pass_transform_pre_inlining,
+    },
+};
+use crate::suite::{
+    mir_pass_transform_pre_inlining::{D2Renderer, TextRenderer},
+    mir_reify::{d2_output_enabled, mir_spawn_d2},
+};
+
+pub(crate) fn mir_pass_transform_inline<'heap>(
+    heap: &'heap Heap,
+    expr: Expr<'heap>,
+    config: InlineConfig,
+    interner: &Interner<'heap>,
+    mut render: impl MirRenderer,
+    environment: &mut Environment<'heap>,
+    diagnostics: &mut Vec<SuiteDiagnostic>,
+) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
+    let (root, mut bodies, mut scratch) = mir_pass_transform_pre_inlining(
+        heap,
+        expr,
+        interner,
+        &mut render,
+        environment,
+        diagnostics,
+    )?;
+
+    let mut context = MirContext {
+        heap,
+        env: environment,
+        interner,
+        diagnostics: DiagnosticIssues::new(),
+    };
+
+    let mut pass = Inline::new_in(config, &mut scratch);
+    let _: Changed = pass.run(
+        &mut context,
+        &mut GlobalTransformState::new_in(&bodies, heap),
+        &mut bodies,
+    );
+    scratch.reset();
+
+    process_issues(diagnostics, context.diagnostics)?;
+
+    render.render(
+        &mut RenderContext {
+            heap,
+            env: environment,
+            stage: Stage {
+                id: "inline",
+                title: "Inlined MIR",
+            },
+            root,
+        },
+        &bodies,
+    );
+
+    Ok((root, bodies, scratch))
+}
+
+pub(crate) struct MirPassTransformInline;
+
+impl Suite for MirPassTransformInline {
+    fn priority(&self) -> usize {
+        1
+    }
+
+    fn name(&self) -> &'static str {
+        "mir/pass/transform/inline"
+    }
+
+    fn description(&self) -> &'static str {
+        "Inlining in the MIR"
+    }
+
+    fn secondary_file_extensions(&self) -> &[&str] {
+        &["svg"]
+    }
+
+    fn run<'heap>(
+        &self,
+        RunContext {
+            heap,
+            diagnostics,
+            suite_directives,
+            reports,
+            secondary_outputs,
+            ..
+        }: RunContext<'_, 'heap>,
+        expr: Expr<'heap>,
+    ) -> Result<String, SuiteDiagnostic> {
+        let mut environment = Environment::new(heap);
+        let interner = Interner::new(heap);
+
+        let mut config = InlineConfig::default();
+
+        #[expect(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+        if let Some(aggressive_inline_cutoff) = suite_directives
+            .get("aggressive-inline-cutoff")
+            .and_then(toml::Value::as_integer)
+        {
+            config.aggressive_inline_cutoff = aggressive_inline_cutoff as usize;
+        }
+
+        #[expect(clippy::cast_possible_truncation)]
+        if let Some(rvalue_input_cost) = suite_directives
+            .get("rvalue-input-cost")
+            .and_then(toml::Value::as_float)
+        {
+            config.cost.rvalue_input = rvalue_input_cost as f32;
+        }
+
+        #[expect(clippy::cast_possible_truncation)]
+        if let Some(max_cost) = suite_directives
+            .get("max-cost")
+            .and_then(toml::Value::as_float)
+        {
+            config.heuristics.max = max_cost as f32;
+        }
+
+        let skip_output = suite_directives
+            .get("skip-output")
+            .and_then(toml::Value::as_bool)
+            .unwrap_or(false);
+
+        let mut buffer = Vec::new();
+        let mut d2 = d2_output_enabled(self, suite_directives, reports).then(mir_spawn_d2);
+
+        mir_pass_transform_inline(
+            heap,
+            expr,
+            config,
+            &interner,
+            (
+                TextRenderer::new(&mut buffer),
+                d2.as_mut().map(|(writer, _)| D2Renderer::new(writer)),
+            ),
+            &mut environment,
+            diagnostics,
+        )?;
+
+        if let Some((mut writer, handle)) = d2 {
+            writer.flush().expect("should be able to write to buffer");
+            drop(writer);
+
+            let diagram = handle.join().expect("should be able to join handle");
+            let diagram = String::from_utf8_lossy_owned(diagram);
+
+            secondary_outputs.insert("svg", diagram);
+        }
+
+        if skip_output {
+            return Ok("[output intentionally skipped]".to_owned());
+        }
+
+        Ok(String::from_utf8_lossy_owned(buffer))
+    }
+}

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

@@ -2,7 +2,7 @@ use std::io::Write as _;
 
 use hashql_ast::node::expr::Expr;
 use hashql_core::{
-    heap::{Heap, Scratch},
+    heap::{Heap, ResetAllocator as _, Scratch},
     r#type::environment::Environment,
 };
 use hashql_diagnostics::DiagnosticIssues;
@@ -52,6 +52,7 @@ pub(crate) fn mir_pass_transform_inst_simplify<'heap>(
     for body in bodies.as_mut_slice() {
         let _: Changed = pass.run(&mut context, body);
     }
+    scratch.reset();
 
     process_issues(diagnostics, context.diagnostics)?;
     Ok((root, bodies, scratch))

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

@@ -22,8 +22,8 @@ use crate::suite::{
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) struct Stage {
-    id: &'static str,
-    title: &'static str,
+    pub id: &'static str,
+    pub title: &'static str,
 }
 
 pub(crate) struct RenderContext<'env, 'heap> {

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

@@ -25,6 +25,7 @@ mod mir_pass_transform_administrative_reduction;
 mod mir_pass_transform_cfg_simplify;
 mod mir_pass_transform_dse;
 mod mir_pass_transform_forward_substitution;
+mod mir_pass_transform_inline;
 mod mir_pass_transform_inst_simplify;
 mod mir_pass_transform_pre_inlining;
 mod mir_reify;
@@ -61,6 +62,7 @@ use self::{
     mir_pass_transform_cfg_simplify::MirPassTransformCfgSimplify,
     mir_pass_transform_dse::MirPassTransformDse,
     mir_pass_transform_forward_substitution::MirPassTransformForwardSubstitution,
+    mir_pass_transform_inline::MirPassTransformInline,
     mir_pass_transform_inst_simplify::MirPassTransformInstSimplify,
     mir_pass_transform_pre_inlining::MirPassTransformPreInlining, mir_reify::MirReifySuite,
     parse_syntax_dump::ParseSyntaxDumpSuite,
@@ -162,6 +164,7 @@ const SUITES: &[&dyn Suite] = &[
     &MirPassTransformCfgSimplify,
     &MirPassTransformDse,
     &MirPassTransformForwardSubstitution,
+    &MirPassTransformInline,
     &MirPassTransformInstSimplify,
     &MirPassTransformPreInlining,
     &MirReifySuite,

libs/@local/hashql/core/package.json

@@ -9,7 +9,7 @@
     "fix:clippy": "just clippy --fix",
     "lint:clippy": "just clippy",
     "test:codspeed": "cargo codspeed run -p hashql-core",
-    "test:miri": "cargo miri nextest run -- co_sort try_scan heap::transfer stable_empty_slice",
+    "test:miri": "cargo miri nextest run -- co_sort try_scan heap::transfer stable_empty_slice id::slice tarjan::tests::members",
     "test:unit": "mise run test:unit @rust/hashql-core"
   },
   "dependencies": {

libs/@local/hashql/core/src/collections/work_queue.rs

@@ -85,7 +85,7 @@ where
     #[must_use]
     pub fn new_in(domain_size: usize, alloc: A) -> Self {
         Self {
-            queue: VecDeque::new_in(alloc),
+            queue: VecDeque::with_capacity_in(domain_size, alloc),
             set: DenseBitSet::new_empty(domain_size),
         }
     }

libs/@local/hashql/core/src/graph/algorithms/dominators/mod.rs

@@ -465,7 +465,7 @@ fn compute_access_time<N: Id>(
     }
 
     let mut max = EdgeIndex::from_u32(0);
-    for edge in edges.iter_mut() {
+    for edge in &mut edges {
         max.increment_by(edge.end.as_usize());
         edge.start = max;
         edge.end = max;