feat: inst simplify

Author: indietyp

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

@@ -107,7 +107,7 @@ use crate::{
         location::Location,
         operand::Operand,
         place::Place,
-        rvalue::{BinOp, Binary, RValue, Unary},
+        rvalue::{Aggregate, AggregateKind, BinOp, Binary, RValue, Unary},
         statement::Assign,
     },
     context::MirContext,
@@ -503,6 +503,19 @@ impl<'heap, A: Allocator> VisitorMut<'heap> for InstSimplifyVisitor<'_, 'heap, A
         Ok(())
     }
 
+    fn visit_rvalue_aggregate(
+        &mut self,
+        _: Location,
+        aggregate: &mut Aggregate<'heap>,
+    ) -> Self::Result<()> {
+        // Specialize into a unit if it's an empty tuple
+        if aggregate.kind == AggregateKind::Tuple && aggregate.operands.is_empty() {
+            self.trampoline = Some(RValue::Load(Operand::Constant(Constant::Unit)));
+        }
+
+        Ok(())
+    }
+
     fn visit_statement_assign(
         &mut self,
         location: Location,

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

@@ -64,10 +64,6 @@ fn assert_inst_simplify_pass<'heap>(
     assert_snapshot!(name, value);
 }
 
-// =============================================================================
-// Constant Folding (Bitwise on integers, Unary - not in source language)
-// =============================================================================
-
 /// Tests constant folding for bitwise AND on integers.
 #[test]
 fn const_fold_bit_and() {
@@ -180,10 +176,6 @@ fn const_fold_unary_neg() {
     );
 }
 
-// =============================================================================
-// Bitwise Identity on Integers (x | 0 => x - not in source language)
-// =============================================================================
-
 /// Tests identity simplification for bitwise OR with zero.
 #[test]
 fn identity_bit_or_zero() {
@@ -212,10 +204,6 @@ fn identity_bit_or_zero() {
     );
 }
 
-// =============================================================================
-// Identical Operand Patterns (BitAnd/BitOr on integers - not in source)
-// =============================================================================
-
 /// Tests idempotent simplification for bitwise AND with identical operands.
 #[test]
 fn identical_operand_bit_and() {
@@ -272,10 +260,6 @@ fn identical_operand_bit_or() {
     );
 }
 
-// =============================================================================
-// Block Parameter Propagation (requires CFG control)
-// =============================================================================
-
 /// Tests constant propagation through block params with single predecessor.
 #[test]
 fn block_param_single_predecessor() {
@@ -381,10 +365,6 @@ fn block_param_predecessors_disagree() {
     );
 }
 
-// =============================================================================
-// Idempotent to Constant Forwarding (requires bitwise op)
-// =============================================================================
-
 /// Tests that idempotent simplification propagates constants through the result.
 #[test]
 fn idempotent_to_const_forwarding() {