BE-248, BE-252: HashQL: Implement Dead Local Elimination (DLE) and use bump allocator throughout passes (#8198)

Author: indietyp

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

@@ -4,7 +4,10 @@ use std::{
 };
 
 use hashql_ast::node::expr::Expr;
-use hashql_core::{heap::Heap, r#type::environment::Environment};
+use hashql_core::{
+    heap::{Heap, Scratch},
+    r#type::environment::Environment,
+};
 use hashql_diagnostics::DiagnosticIssues;
 use hashql_mir::{
     body::Body,
@@ -45,7 +48,7 @@ pub(crate) fn mir_pass_transform_cfg_simplify<'heap>(
     render: impl FnOnce(&'heap Heap, &Environment<'heap>, DefId, &DefIdSlice<Body<'heap>>),
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
-) -> Result<(DefId, DefIdVec<Body<'heap>>), SuiteDiagnostic> {
+) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
     let (root, mut bodies) = mir_reify(heap, expr, interner, environment, diagnostics)?;
 
     render(heap, environment, root, &bodies);
@@ -56,15 +59,16 @@ pub(crate) fn mir_pass_transform_cfg_simplify<'heap>(
         interner,
         diagnostics: DiagnosticIssues::new(),
     };
+    let mut scratch = Scratch::new();
 
-    let mut pass = CfgSimplify::new();
+    let mut pass = CfgSimplify::new_in(&mut scratch);
     for body in bodies.as_mut_slice() {
         pass.run(&mut context, body);
     }
 
     process_issues(diagnostics, context.diagnostics)?;
 
-    Ok((root, bodies))
+    Ok((root, bodies, scratch))
 }
 
 pub(crate) struct MirPassTransformCfgSimplify;
@@ -104,7 +108,7 @@ impl Suite for MirPassTransformCfgSimplify {
         let mut buffer = Vec::new();
         let mut d2 = d2_output_enabled(self, suite_directives, reports).then(mir_spawn_d2);
 
-        let (root, bodies) = mir_pass_transform_cfg_simplify(
+        let (root, bodies, _) = mir_pass_transform_cfg_simplify(
             heap,
             expr,
             &interner,

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

@@ -1,7 +1,10 @@
 use std::io::Write as _;
 
 use hashql_ast::node::expr::Expr;
-use hashql_core::{heap::Heap, r#type::environment::Environment};
+use hashql_core::{
+    heap::{Heap, Scratch},
+    r#type::environment::Environment,
+};
 use hashql_diagnostics::DiagnosticIssues;
 use hashql_mir::{
     body::Body,
@@ -28,8 +31,8 @@ pub(crate) fn mir_pass_transform_dse<'heap>(
     render: impl FnOnce(&'heap Heap, &Environment<'heap>, DefId, &DefIdSlice<Body<'heap>>),
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
-) -> Result<(DefId, DefIdVec<Body<'heap>>), SuiteDiagnostic> {
-    let (root, mut bodies) =
+) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
+    let (root, mut bodies, mut scratch) =
         mir_pass_transform_sroa(heap, expr, interner, render, environment, diagnostics)?;
 
     let mut context = MirContext {
@@ -39,13 +42,13 @@ pub(crate) fn mir_pass_transform_dse<'heap>(
         diagnostics: DiagnosticIssues::new(),
     };
 
-    let mut pass = DeadStoreElimination::new();
+    let mut pass = DeadStoreElimination::new_in(&mut scratch);
     for body in bodies.as_mut_slice() {
         pass.run(&mut context, body);
     }
 
     process_issues(diagnostics, context.diagnostics)?;
-    Ok((root, bodies))
+    Ok((root, bodies, scratch))
 }
 
 pub(crate) struct MirPassTransformDse;
@@ -85,7 +88,7 @@ impl Suite for MirPassTransformDse {
         let mut buffer = Vec::new();
         let mut d2 = d2_output_enabled(self, suite_directives, reports).then(mir_spawn_d2);
 
-        let (root, bodies) = mir_pass_transform_dse(
+        let (root, bodies, _) = mir_pass_transform_dse(
             heap,
             expr,
             &interner,

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

@@ -1,7 +1,10 @@
 use std::io::Write as _;
 
 use hashql_ast::node::expr::Expr;
-use hashql_core::{heap::Heap, r#type::environment::Environment};
+use hashql_core::{
+    heap::{Heap, Scratch},
+    r#type::environment::Environment,
+};
 use hashql_diagnostics::DiagnosticIssues;
 use hashql_mir::{
     body::Body,
@@ -28,8 +31,8 @@ pub(crate) fn mir_pass_transform_sroa<'heap>(
     render: impl FnOnce(&'heap Heap, &Environment<'heap>, DefId, &DefIdSlice<Body<'heap>>),
     environment: &mut Environment<'heap>,
     diagnostics: &mut Vec<SuiteDiagnostic>,
-) -> Result<(DefId, DefIdVec<Body<'heap>>), SuiteDiagnostic> {
-    let (root, mut bodies) =
+) -> Result<(DefId, DefIdVec<Body<'heap>>, Scratch), SuiteDiagnostic> {
+    let (root, mut bodies, mut scratch) =
         mir_pass_transform_cfg_simplify(heap, expr, interner, render, environment, diagnostics)?;
 
     let mut context = MirContext {
@@ -39,13 +42,13 @@ pub(crate) fn mir_pass_transform_sroa<'heap>(
         diagnostics: DiagnosticIssues::new(),
     };
 
-    let mut pass = Sroa::new();
+    let mut pass = Sroa::new_in(&mut scratch);
     for body in bodies.as_mut_slice() {
         pass.run(&mut context, body);
     }
 
     process_issues(diagnostics, context.diagnostics)?;
-    Ok((root, bodies))
+    Ok((root, bodies, scratch))
 }
 
 pub(crate) struct MirPassTransformSroa;
@@ -85,7 +88,7 @@ impl Suite for MirPassTransformSroa {
         let mut buffer = Vec::new();
         let mut d2 = d2_output_enabled(self, suite_directives, reports).then(mir_spawn_d2);
 
-        let (root, bodies) = mir_pass_transform_sroa(
+        let (root, bodies, _) = mir_pass_transform_sroa(
             heap,
             expr,
             &interner,

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

@@ -9,12 +9,13 @@ use hashbrown::{HashMap, HashSet};
 
 pub use self::{hash_map::HashMapExt, work_queue::WorkQueue};
 
-pub type FastHashMap<K, V, A = Global> = HashMap<K, V, foldhash::fast::RandomState, A>;
+pub type FastHasher = foldhash::fast::RandomState;
+
+pub type FastHashMap<K, V, A = Global> = HashMap<K, V, FastHasher, A>;
 pub type FastHashMapEntry<'map, K, V, A = Global> =
-    hashbrown::hash_map::Entry<'map, K, V, foldhash::fast::RandomState, A>;
-pub type FastHashSet<T, A = Global> = HashSet<T, foldhash::fast::RandomState, A>;
-pub type FastHashSetEntry<'map, T, A = Global> =
-    hashbrown::hash_set::Entry<'map, T, foldhash::fast::RandomState, A>;
+    hashbrown::hash_map::Entry<'map, K, V, FastHasher, A>;
+pub type FastHashSet<T, A = Global> = HashSet<T, FastHasher, A>;
+pub type FastHashSetEntry<'map, T, A = Global> = hashbrown::hash_set::Entry<'map, T, FastHasher, A>;
 
 #[inline]
 #[must_use]

libs/@local/hashql/core/src/heap/allocator.rs

@@ -4,6 +4,8 @@ use core::{alloc, ptr};
 
 use bumpalo::Bump;
 
+use super::BumpAllocator;
+
 /// Internal arena allocator.
 #[derive(Debug)]
 pub(super) struct Allocator(Bump);
@@ -22,12 +24,6 @@ impl Allocator {
         Self(Bump::with_capacity(capacity))
     }
 
-    /// Resets the allocator, invalidating all allocations but retaining capacity.
-    #[inline]
-    pub(crate) fn reset(&mut self) {
-        self.0.reset();
-    }
-
     /// Allocates a value using a closure to avoid moving before allocation.
     #[inline]
     pub(crate) fn alloc_with<T>(&self, func: impl FnOnce() -> T) -> &mut T {
@@ -44,13 +40,17 @@ impl Allocator {
             .try_alloc_slice_copy(slice)
             .map_err(|_err| alloc::AllocError)
     }
+}
+
+impl BumpAllocator for Allocator {
+    #[inline]
+    fn allocate_slice_copy<T: Copy>(&self, slice: &[T]) -> Result<&mut [T], alloc::AllocError> {
+        self.try_alloc_slice_copy(slice)
+    }
 
-    /// Copies a string into the arena.
     #[inline]
-    pub(crate) fn try_alloc_str(&self, string: &str) -> Result<&mut str, alloc::AllocError> {
-        self.0
-            .try_alloc_str(string)
-            .map_err(|_err| alloc::AllocError)
+    fn reset(&mut self) {
+        self.0.reset();
     }
 }
 

libs/@local/hashql/core/src/heap/bump.rs

@@ -0,0 +1,110 @@
+//! Bump allocator trait for arena-style memory management.
+//!
+//! This module provides the [`BumpAllocator`] trait, an extension to the standard
+//! [`Allocator`] trait that adds support for bulk deallocation via [`reset`](BumpAllocator::reset).
+//!
+//! # Overview
+//!
+//! Bump allocators (also known as arena allocators) allocate memory by incrementing
+//! a pointer ("bumping") within a contiguous memory region. Individual deallocations
+//! are not supported; instead, all allocations are freed at once by resetting the
+//! bump pointer.
+//!
+//! This trade-off makes bump allocators ideal for:
+//!
+//! - **Compiler passes**: Temporary data structures that live for a single pass
+//! - **AST construction**: Nodes allocated during parsing, freed after compilation
+//! - **Batch processing**: Work items processed together, then discarded
+//!
+//! # Usage
+//!
+//! The trait is implemented by [`Heap`] and [`Scratch`] allocators:
+//!
+//! ```
+//! # #![feature(allocator_api)]
+//! use hashql_core::heap::{BumpAllocator, CollectIn, Scratch};
+//!
+//! let mut scratch = Scratch::new();
+//!
+//! // Allocate some data
+//! let vec: Vec<u32, &Scratch> = (1..=3).collect_in(&scratch);
+//! drop(vec);
+//!
+//! // Reset frees all allocations at once
+//! scratch.reset();
+//! ```
+//!
+//! # Pass Pattern
+//!
+//! Compiler passes commonly reset the allocator at the start of `run()` to reuse
+//! memory from previous invocations:
+//!
+//! ```ignore
+//! impl TransformPass for MyPass<A: BumpAllocator> {
+//!     fn run(&mut self, context: &mut Context, body: &mut Body) {
+//!         self.alloc.reset();  // Reuse memory from previous run
+//!         // ... pass implementation using self.alloc ...
+//!     }
+//! }
+//! ```
+//!
+//! [`Heap`]: super::Heap
+//! [`Scratch`]: super::Scratch
+#![expect(clippy::mut_from_ref, reason = "allocator")]
+use core::alloc::{AllocError, Allocator};
+
+/// A bump allocator that supports bulk deallocation.
+///
+/// This trait extends [`Allocator`] with arena-style memory management:
+/// allocations are made by bumping a pointer, and all memory is freed at once
+/// via [`reset`](Self::reset).
+///
+/// # Implementors
+///
+/// - [`Heap`](super::Heap): Full-featured arena with string interning
+/// - [`Scratch`](super::Scratch): Lightweight arena for temporary allocations
+pub trait BumpAllocator: Allocator {
+    /// Copies a slice into the arena, returning a mutable reference to the copy.
+    ///
+    /// This is useful for transferring borrowed data into arena-owned memory.
+    /// The source slice is copied element-by-element into freshly allocated arena memory.
+    ///
+    /// # Type Requirements
+    ///
+    /// The element type must be [`Copy`] to ensure safe bitwise copying without
+    /// running destructors on the source data.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`AllocError`] if memory allocation fails.
+    fn allocate_slice_copy<T: Copy>(&self, slice: &[T]) -> Result<&mut [T], AllocError>;
+
+    /// Resets the allocator, freeing all allocations at once.
+    ///
+    /// After calling `reset`, the allocator's memory is available for reuse.
+    /// All previously allocated references become invalid; using them is
+    /// undefined behavior (prevented by Rust's borrow checker in safe code).
+    ///
+    /// The allocator retains its current capacity, avoiding reallocation
+    /// on subsequent use.
+    fn reset(&mut self);
+}
+
+/// Blanket implementation allowing `&mut A` to be used where `A: BumpAllocator`.
+///
+/// This enables passes to store `&mut Scratch` or `&mut Heap` while still
+/// calling [`reset`](BumpAllocator::reset) through the mutable reference.
+impl<A> BumpAllocator for &mut A
+where
+    A: BumpAllocator,
+{
+    #[inline]
+    fn allocate_slice_copy<T: Copy>(&self, slice: &[T]) -> Result<&mut [T], AllocError> {
+        A::allocate_slice_copy(self, slice)
+    }
+
+    #[inline]
+    fn reset(&mut self) {
+        A::reset(self);
+    }
+}

libs/@local/hashql/core/src/heap/mod.rs

@@ -93,6 +93,7 @@
 //! ```
 #![expect(unsafe_code)]
 mod allocator;
+mod bump;
 mod clone;
 mod convert;
 mod iter;
@@ -107,6 +108,7 @@ use hashbrown::HashSet;
 
 use self::allocator::Allocator;
 pub use self::{
+    bump::BumpAllocator,
     clone::{CloneIn, TryCloneIn},
     convert::{FromIn, IntoIn},
     iter::{CollectIn, FromIteratorIn},
@@ -239,27 +241,6 @@ impl Heap {
         }
     }
 
-    /// Resets the heap, invalidating all previous allocations.
-    ///
-    /// Clears all allocations and re-primes with common symbols.
-    /// The allocator retains its current capacity.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the internal mutex is poisoned.
-    pub fn reset(&mut self) {
-        // IMPORTANT: Clear strings BEFORE resetting the arena to prevent dangling references.
-        // The HashSet stores `&'static str` that actually point into arena memory.
-        {
-            let mut strings = self.strings.lock().expect("lock should not be poisoned");
-            strings.clear();
-            Self::prime_symbols(&mut strings);
-            drop(strings);
-        }
-
-        self.inner.reset();
-    }
-
     /// Allocates a value in the arena, returning a mutable reference.
     ///
     /// Only accepts types that do **not** require [`Drop`]. Types requiring destructors
@@ -321,6 +302,35 @@ impl Default for Heap {
     }
 }
 
+impl BumpAllocator for Heap {
+    #[inline]
+    fn allocate_slice_copy<T: Copy>(&self, slice: &[T]) -> Result<&mut [T], alloc::AllocError> {
+        self.inner.try_alloc_slice_copy(slice)
+    }
+
+    /// Resets the heap, invalidating all previous allocations.
+    ///
+    /// Clears all allocations and re-primes with common symbols.
+    /// The allocator retains its current capacity.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the internal mutex is poisoned.
+    #[inline]
+    fn reset(&mut self) {
+        // IMPORTANT: Clear strings BEFORE resetting the arena to prevent dangling references.
+        // The HashSet stores `&'static str` that actually point into arena memory.
+        {
+            let mut strings = self.strings.lock().expect("lock should not be poisoned");
+            strings.clear();
+            Self::prime_symbols(&mut strings);
+            drop(strings);
+        }
+
+        self.inner.reset();
+    }
+}
+
 // SAFETY: Delegates to bumpalo::Bump via the internal Allocator.
 #[expect(unsafe_code, reason = "proxy to internal allocator")]
 unsafe impl alloc::Allocator for Heap {