fix: suggestions from review

Author: indietyp

libs/@local/hashql/mir/src/interpret/value/int.rs

@@ -322,7 +322,7 @@ impl Display for Int {
 impl PartialEq for Int {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.size == other.size && self.as_int() == other.as_int()
+        self.as_int() == other.as_int() && self.size == other.size
     }
 }
 
@@ -338,9 +338,9 @@ impl PartialOrd for Int {
 impl Ord for Int {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.size
-            .cmp(&other.size)
-            .then_with(|| self.as_int().cmp(&other.as_int()))
+        self.as_int()
+            .cmp(&other.as_int())
+            .then_with(|| self.size.cmp(&other.size))
     }
 }
 

libs/@local/hashql/mir/src/interpret/value/mod.rs

@@ -472,6 +472,10 @@ impl<A: Allocator> Ord for Value<'_, A> {
             (Value::Integer(this), Value::Integer(other)) => this.cmp(other),
             (Value::Number(this), Value::Number(other)) => this.cmp(other),
 
+            // Bool is a separate type from Int/Number in the subtype lattice, so
+            // cross-type numeric comparison only applies to integers. Booleans fall
+            // through to discriminant ordering (which is fine: no well-typed program
+            // can observe the ordering between Bool and Number).
             (Value::Integer(this), Value::Number(other)) if !this.is_bool() => {
                 other.cmp_int(this).reverse()
             }

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

@@ -322,20 +322,28 @@ impl<'heap, A: Allocator> InstSimplifyVisitor<'_, 'heap, A> {
             }
             (BinOp::BitOr, _) => None,
             // true == rhs => rhs (boolean equivalence)
-            (BinOp::Eq, 1) if is_bool => Some(RValue::Load(Operand::Place(rhs))),
+            (BinOp::Eq, 1) if is_bool && lhs.is_bool() => Some(RValue::Load(Operand::Place(rhs))),
             // false == rhs => !rhs == ~rhs (boolean equivalence)
-            (BinOp::Eq, 0) if is_bool => Some(RValue::Unary(Unary {
+            (BinOp::Eq, 0) if is_bool && lhs.is_bool() => Some(RValue::Unary(Unary {
                 op: UnOp::BitNot,
                 operand: Operand::Place(rhs),
             })),
+            // bool == int => false
+            (BinOp::Eq, _) if is_bool && !lhs.is_bool() => {
+                Some(RValue::Load(Operand::Constant(Constant::Int(Int::FALSE))))
+            }
             (BinOp::Eq, _) => None,
             // false != rhs => rhs (boolean equivalence)
-            (BinOp::Ne, 0) if is_bool => Some(RValue::Load(Operand::Place(rhs))),
+            (BinOp::Ne, 0) if is_bool && lhs.is_bool() => Some(RValue::Load(Operand::Place(rhs))),
             // true != rhs => !rhs == ~rhs (boolean equivalence)
-            (BinOp::Ne, 1) if is_bool => Some(RValue::Unary(Unary {
+            (BinOp::Ne, 1) if is_bool && lhs.is_bool() => Some(RValue::Unary(Unary {
                 op: UnOp::BitNot,
                 operand: Operand::Place(rhs),
             })),
+            // bool != int => true
+            (BinOp::Ne, _) if is_bool && !lhs.is_bool() => {
+                Some(RValue::Load(Operand::Constant(Constant::Int(Int::TRUE))))
+            }
             (BinOp::Ne, _) => None,
             (BinOp::Lt, _) => None,
             (BinOp::Lte, _) => None,
@@ -373,7 +381,7 @@ impl<'heap, A: Allocator> InstSimplifyVisitor<'_, 'heap, A> {
             (BinOp::BitAnd, 0) if is_bool => {
                 Some(RValue::Load(Operand::Constant(Constant::Int(false.into()))))
             }
-            // 0 & lhs => 0 (annihilator)
+            // lhs & 0 => 0 (annihilator)
             (BinOp::BitAnd, 0) => Some(RValue::Load(Operand::Constant(Constant::Int(0.into())))),
             (BinOp::BitAnd, _) => None,
             // lhs | 0 => lhs (identity)
@@ -384,20 +392,28 @@ impl<'heap, A: Allocator> InstSimplifyVisitor<'_, 'heap, A> {
             }
             (BinOp::BitOr, _) => None,
             // lhs == true => lhs (boolean equivalence)
-            (BinOp::Eq, 1) if is_bool => Some(RValue::Load(Operand::Place(lhs))),
+            (BinOp::Eq, 1) if is_bool && rhs.is_bool() => Some(RValue::Load(Operand::Place(lhs))),
             // lhs == false => !lhs == ~lhs (boolean equivalence)
-            (BinOp::Eq, 0) if is_bool => Some(RValue::Unary(Unary {
+            (BinOp::Eq, 0) if is_bool && rhs.is_bool() => Some(RValue::Unary(Unary {
                 op: UnOp::BitNot,
                 operand: Operand::Place(lhs),
             })),
+            // bool == int => false
+            (BinOp::Eq, _) if is_bool && !rhs.is_bool() => {
+                Some(RValue::Load(Operand::Constant(Constant::Int(Int::FALSE))))
+            }
             (BinOp::Eq, _) => None,
             // lhs != false => lhs (boolean equivalence)
-            (BinOp::Ne, 0) if is_bool => Some(RValue::Load(Operand::Place(lhs))),
+            (BinOp::Ne, 0) if is_bool && rhs.is_bool() => Some(RValue::Load(Operand::Place(lhs))),
             // lhs != true => !lhs == ~lhs (boolean equivalence)
-            (BinOp::Ne, 1) if is_bool => Some(RValue::Unary(Unary {
+            (BinOp::Ne, 1) if is_bool && rhs.is_bool() => Some(RValue::Unary(Unary {
                 op: UnOp::BitNot,
                 operand: Operand::Place(lhs),
             })),
+            // bool != int => true
+            (BinOp::Ne, _) if is_bool && !rhs.is_bool() => {
+                Some(RValue::Load(Operand::Constant(Constant::Int(Int::TRUE))))
+            }
             (BinOp::Ne, _) => None,
             (BinOp::Lt, _) => None,
             (BinOp::Lte, _) => None,

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

@@ -278,6 +278,124 @@ fn const_fold_eq_bool_vs_int() {
     );
 }
 
+/// Regression: `bool_place == int(1)` must fold to `false`, not simplify to `bool_place`.
+///
+/// With structural typing, a Bool-typed place can be compared against an Int constant.
+/// The types have no intersection: booleans (size 1) can never equal integers (size 128).
+#[test]
+fn eq_bool_place_vs_int_constant_right() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/1 -> Bool {
+        decl x: Bool, result: Bool;
+
+        bb0() {
+            result = bin.== x 1;
+            return result;
+        }
+    });
+
+    assert_inst_simplify_pass(
+        "eq_bool_place_vs_int_constant_right",
+        body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
+/// Same as above but with the constant on the left: `1 == bool_place`.
+#[test]
+fn eq_bool_place_vs_int_constant_left() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/1 -> Bool {
+        decl x: Bool, result: Bool;
+
+        bb0() {
+            result = bin.== 1 x;
+            return result;
+        }
+    });
+
+    assert_inst_simplify_pass(
+        "eq_bool_place_vs_int_constant_left",
+        body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
+/// Regression: `bool_place != int(0)` must fold to `true`, not simplify to `bool_place`.
+///
+/// The Ne counterpart of the eq tests above. Bool and Int have no intersection,
+/// so they are always unequal.
+#[test]
+fn ne_bool_place_vs_int_constant_right() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/1 -> Bool {
+        decl x: Bool, result: Bool;
+
+        bb0() {
+            result = bin.!= x 0;
+            return result;
+        }
+    });
+
+    assert_inst_simplify_pass(
+        "ne_bool_place_vs_int_constant_right",
+        body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
+/// Same as above but with the constant on the left: `0 != bool_place`.
+#[test]
+fn ne_bool_place_vs_int_constant_left() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/1 -> Bool {
+        decl x: Bool, result: Bool;
+
+        bb0() {
+            result = bin.!= 0 x;
+            return result;
+        }
+    });
+
+    assert_inst_simplify_pass(
+        "ne_bool_place_vs_int_constant_left",
+        body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
 /// Tests constant folding for unary NOT.
 #[test]
 fn const_fold_unary_not() {