feat: checkpoint

fix: checkpoint

feat: checkpoint

feat: checkpoint

feat: checkpoint

feat: checkpoint

fix: checkpoint

fix: checkpoint

fix: checkpoint

feat: checkpoint

feat: checkpoint

chore: better unreachable messages

feat: add lookup methods

fix: add tests directory

feat: bb checkpoint

feat: bb checkpoint

test: checkpoint

feat: first test

fix: lints

feat: test cases

Author: indietyp

Cargo.lock

@@ -80,3 +80,4 @@ pub fn fast_hash_set<T>() -> FastHashSet<T> {
 
 pub type TinyVec<T> = smallvec::SmallVec<T, 4>;
 pub type SmallVec<T> = smallvec::SmallVec<T, 16>;
+pub type InlineVec<T, const N: usize> = smallvec::SmallVec<T, N>;

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

@@ -110,6 +110,12 @@ where
         self.inner.is_empty()
     }
 
+    /// Returns `true` if the iterated dominance frontier contains the given node.
+    #[must_use]
+    pub fn contains(&self, node: N) -> bool {
+        self.inner.contains(node)
+    }
+
     /// Returns the number of nodes in the iterated dominance frontier.
     #[must_use]
     pub fn count(&self) -> usize {

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

@@ -190,6 +190,90 @@ where
     }
 }
 
+impl<I, T> IdSlice<I, Option<T>>
+where
+    I: Id,
+{
+    /// Removes and returns the value at the given ID index.
+    ///
+    /// Returns `None` if the index is out of bounds or if the value was already `None`.
+    /// The vector is not shrunk after removal.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
+    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
+    /// let mut vec = IdVec::<MyId, Option<String>>::new();
+    /// vec.insert(MyId::from_usize(0), "hello".to_string());
+    /// let removed = vec.remove(MyId::from_usize(0));
+    /// assert_eq!(removed, Some("hello".to_string()));
+    /// assert!(vec[MyId::from_usize(0)].is_none());
+    /// ```
+    pub fn remove(&mut self, index: I) -> Option<T> {
+        self.get_mut(index)?.take()
+    }
+
+    /// Returns `true` if the vector contains a value (not `None`) at the given ID index.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
+    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
+    /// let mut vec = IdVec::<MyId, Option<String>>::new();
+    /// vec.insert(MyId::from_usize(0), "hello".to_string());
+    /// assert!(vec.contains(MyId::from_usize(0)));
+    /// assert!(!vec.contains(MyId::from_usize(1)));
+    /// ```
+    pub fn contains(&self, index: I) -> bool {
+        self.get(index).and_then(Option::as_ref).is_some()
+    }
+
+    /// Gets a reference to the inner value at `index`, if present.
+    ///
+    /// Returns [`None`] if the index is out of bounds or if the value at that index is [`None`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
+    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
+    /// let mut vec = IdVec::<MyId, Option<String>>::new();
+    /// vec.insert(MyId::from_usize(0), "hello".to_string());
+    ///
+    /// assert_eq!(vec.lookup(MyId::from_usize(0)), Some(&"hello".to_string()));
+    /// assert_eq!(vec.lookup(MyId::from_usize(1)), None); // out of bounds
+    /// ```
+    pub fn lookup(&self, index: I) -> Option<&T> {
+        self.get(index).and_then(Option::as_ref)
+    }
+
+    /// Gets a mutable reference to the inner value at `index`, if present.
+    ///
+    /// Returns [`None`] if the index is out of bounds or if the value at that index is [`None`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
+    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
+    /// let mut vec = IdVec::<MyId, Option<String>>::new();
+    /// vec.insert(MyId::from_usize(0), "hello".to_string());
+    ///
+    /// if let Some(value) = vec.lookup_mut(MyId::from_usize(0)) {
+    ///     value.push_str(" world");
+    /// }
+    /// assert_eq!(
+    ///     vec.lookup(MyId::from_usize(0)),
+    ///     Some(&"hello world".to_string())
+    /// );
+    /// ```
+    pub fn lookup_mut(&mut self, index: I) -> Option<&mut T> {
+        self.get_mut(index).and_then(Option::as_mut)
+    }
+}
+
 impl<I, T> Debug for IdSlice<I, T>
 where
     I: Id,

libs/@local/hashql/core/src/id/slice.rs

@@ -367,42 +367,6 @@ where
         self.fill_until(index, || None).replace(value)
     }
 
-    /// Removes and returns the value at the given ID index.
-    ///
-    /// Returns `None` if the index is out of bounds or if the value was already `None`.
-    /// The vector is not shrunk after removal.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
-    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
-    /// let mut vec = IdVec::<MyId, Option<String>>::new();
-    /// vec.insert(MyId::from_usize(0), "hello".to_string());
-    /// let removed = vec.remove(MyId::from_usize(0));
-    /// assert_eq!(removed, Some("hello".to_string()));
-    /// assert!(vec[MyId::from_usize(0)].is_none());
-    /// ```
-    pub fn remove(&mut self, index: I) -> Option<T> {
-        self.get_mut(index)?.take()
-    }
-
-    /// Returns `true` if the vector contains a value (not `None`) at the given ID index.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use hashql_core::{id::{IdVec, Id as _}, newtype};
-    /// # newtype!(struct MyId(u32 is 0..=0xFFFF_FF00));
-    /// let mut vec = IdVec::<MyId, Option<String>>::new();
-    /// vec.insert(MyId::from_usize(0), "hello".to_string());
-    /// assert!(vec.contains(MyId::from_usize(0)));
-    /// assert!(!vec.contains(MyId::from_usize(1)));
-    /// ```
-    pub fn contains(&self, index: I) -> bool {
-        self.get(index).and_then(Option::as_ref).is_some()
-    }
-
     /// Gets the value at `index`, or inserts one by calling `value` if it doesn't exist.
     ///
     /// This method works on `IdVec<I, Option<T>>` to provide map-like semantics.

libs/@local/hashql/core/src/id/vec.rs

@@ -23,6 +23,7 @@ simple-mermaid = { workspace = true }
 
 [dev-dependencies]
 hashql-compiletest = { workspace = true }
+insta.workspace    = true
 
 [lints]
 workspace = true

libs/@local/hashql/mir/Cargo.toml

@@ -34,3 +34,15 @@ pub enum Operand<'heap> {
     /// value.
     Constant(Constant<'heap>),
 }
+
+impl<'heap> From<Place<'heap>> for Operand<'heap> {
+    fn from(place: Place<'heap>) -> Self {
+        Operand::Place(place)
+    }
+}
+
+impl<'heap> From<Constant<'heap>> for Operand<'heap> {
+    fn from(constant: Constant<'heap>) -> Self {
+        Operand::Constant(constant)
+    }
+}

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

@@ -4,6 +4,8 @@ use crate::body::{local::Local, operand::Operand, place::Projection};
 
 #[derive(Debug)]
 pub struct Interner<'heap> {
+    pub heap: &'heap Heap,
+
     pub locals: InternSet<'heap, [Local]>,
     pub symbols: InternSet<'heap, [Symbol<'heap>]>,
     pub operands: InternSet<'heap, [Operand<'heap>]>,
@@ -13,6 +15,8 @@ pub struct Interner<'heap> {
 impl<'heap> Interner<'heap> {
     pub fn new(heap: &'heap Heap) -> Self {
         Self {
+            heap,
+
             locals: InternSet::new(heap),
             symbols: InternSet::new(heap),
             operands: InternSet::new(heap),

libs/@local/hashql/mir/src/intern.rs

@@ -1 +1,2 @@
 pub mod error;
+pub mod ssa_repair;