test: simplification

Author: indietyp

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

@@ -59,6 +59,12 @@ impl<'heap> Operand<'heap> {
     }
 }
 
+impl From<!> for Operand<'_> {
+    fn from(value: !) -> Self {
+        value
+    }
+}
+
 impl From<Local> for Operand<'_> {
     fn from(local: Local) -> Self {
         Operand::Place(Place::local(local))

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

@@ -311,7 +311,10 @@ macro_rules! body {
     (@type $types:ident; Int) => {
         $types.integer()
     };
-    (@type $types:ident; ($($sub:tt),*)) => {
+    (@type $types:ident; ()) => {
+        $types.tuple([] as [hashql_core::r#type::TypeId; 0])
+    };
+    (@type $types:ident; ($($sub:tt),+)) => {
         $types.tuple([$($crate::builder::body!(@type $types; $sub)),*])
     };
     (@type $types:ident; ($($name:ident: $sub:tt),*)) => {

libs/@local/hashql/mir/src/builder/rvalue.rs

@@ -224,6 +224,11 @@ macro_rules! rvalue {
             rv.closure($def, $env)
         }; $payload; $($rest)*)
     };
+    ($resume:path; $payload:tt; tuple; $($rest:tt)*) => {
+        $resume!(@rvalue |rv| {
+            rv.tuple([] as [!; 0])
+        }; $payload; $($rest)*)
+    };
     ($resume:path; $payload:tt; tuple $($members:tt),+; $($rest:tt)*) => {
         $resume!(@rvalue |rv| {
             let members = [$($crate::builder::_private::operand!(rv; $members)),*];

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

@@ -14,16 +14,15 @@
     // Library Features
     allocator_api,
     assert_matches,
+    binary_heap_drain_sorted,
     const_type_name,
     iter_array_chunks,
     iter_collect_into,
     iter_intersperse,
+    maybe_uninit_fill,
+    step_trait,
     string_from_utf8_lossy_owned,
     try_trait_v2,
-    step_trait,
-    maybe_uninit_fill,
-    binary_heap_into_iter_sorted,
-    binary_heap_drain_sorted,
 )]
 #![expect(clippy::indexing_slicing)]
 extern crate alloc;

libs/@local/hashql/mir/src/pass/transform/inst_simplify/tests.rs

@@ -1,5 +1,5 @@
 #![expect(clippy::min_ident_chars, reason = "tests")]
-use std::{io::Write as _, path::PathBuf};
+use std::{assert_matches::assert_matches, io::Write as _, path::PathBuf};
 
 use bstr::ByteVec as _;
 use hashql_core::{
@@ -12,8 +12,20 @@ use insta::{Settings, assert_snapshot};
 
 use super::InstSimplify;
 use crate::{
-    body::Body, builder::body, context::MirContext, def::DefIdSlice, intern::Interner,
-    pass::TransformPass as _, pretty::TextFormat,
+    body::{
+        Body,
+        basic_block::BasicBlockId,
+        constant::Constant,
+        operand::Operand,
+        rvalue::RValue,
+        statement::{Assign, StatementKind},
+    },
+    builder::body,
+    context::MirContext,
+    def::DefIdSlice,
+    intern::Interner,
+    pass::{Changed, TransformPass as _},
+    pretty::TextFormat,
 };
 
 #[track_caller]
@@ -394,3 +406,38 @@ fn idempotent_to_const_forwarding() {
         },
     );
 }
+
+/// Tests that an empty tuple aggregate is simplified to a unit constant.
+#[test]
+fn empty_tuple_to_unit() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let mut body = body!(interner, env; fn@0/0 -> () {
+        decl result: ();
+
+        bb0() {
+            result = tuple;
+            return result;
+        }
+    });
+
+    let changed = InstSimplify::new().run(
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+        &mut body,
+    );
+    assert_eq!(changed, Changed::Yes);
+    assert_matches!(
+        body.basic_blocks[BasicBlockId::START].statements[0].kind,
+        StatementKind::Assign(Assign {
+            lhs: _,
+            rhs: RValue::Load(Operand::Constant(Constant::Unit))
+        })
+    );
+}