BE-253: HashQL: Optimize away special casing for logical operators in MIR (#8199)

Author: indietyp

libs/@local/hashql/mir/src/body/rvalue/binary.rs

@@ -4,10 +4,101 @@
 //! produce a single result value. They are fundamental building blocks for
 //! arithmetic, logical, and comparison operations in the MIR.
 
-use hashql_hir::node::operation::BinOp;
+use hashql_core::symbol::{Symbol, sym};
 
 use crate::body::operand::Operand;
 
+/// The kinds of binary operators available in HashQL.
+///
+/// Represents the various operations that can be performed with two operands,
+/// including arithmetic, comparison, logical, and bitwise operations.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum BinOp {
+    /// The `+` operator (addition).
+    Add(!),
+    /// The `-` operator (subtraction).
+    Sub(!),
+    /// The `*` operator (multiplication).
+    Mul(!),
+    /// The `/` operator (division).
+    Div(!),
+    /// The `%` operator (remainder).
+    Rem(!),
+    /// The `%%`/`⟲` operator (modulo).
+    Mod(!),
+    /// The `**`/`↑` operator (exponentiation).
+    Pow(!),
+    /// The `^` operator (bitwise xor).
+    BitXor(!),
+    /// The `&` operator (bitwise and).
+    BitAnd,
+    /// The `|` operator (bitwise or).
+    BitOr,
+    /// The `<<` operator (shift left).
+    BitShl(!),
+    /// The `>>` operator (shift right).
+    BitShr(!),
+    /// The `==` operator (equality).
+    Eq,
+    /// The `!=` operator (not equal to).
+    Ne,
+    /// The `<` operator (less than).
+    Lt,
+    /// The `<=` operator (less than or equal to).
+    Lte,
+    /// The `>` operator (greater than).
+    Gt,
+    /// The `>=` operator (greater than or equal to).
+    Gte,
+}
+
+impl BinOp {
+    #[must_use]
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::BitAnd => "&",
+            Self::BitOr => "|",
+            Self::Eq => "==",
+            Self::Lt => "<",
+            Self::Lte => "<=",
+            Self::Ne => "!=",
+            Self::Gte => ">=",
+            Self::Gt => ">",
+        }
+    }
+
+    #[must_use]
+    pub const fn as_symbol(self) -> Symbol<'static> {
+        match self {
+            Self::BitAnd => sym::symbol::ampersand,
+            Self::BitOr => sym::symbol::pipe,
+            Self::Eq => sym::symbol::eq,
+            Self::Lt => sym::symbol::lt,
+            Self::Lte => sym::symbol::lte,
+            Self::Ne => sym::symbol::ne,
+            Self::Gte => sym::symbol::gte,
+            Self::Gt => sym::symbol::gt,
+        }
+    }
+}
+
+impl From<hashql_hir::node::operation::BinOp> for BinOp {
+    fn from(value: hashql_hir::node::operation::BinOp) -> Self {
+        // `And` on bools (what the HIR enforces) is the same as a bitwise `And` and `Or`
+        // respectively
+        match value {
+            hashql_hir::node::operation::BinOp::And => Self::BitAnd,
+            hashql_hir::node::operation::BinOp::Or => Self::BitOr,
+            hashql_hir::node::operation::BinOp::Eq => Self::Eq,
+            hashql_hir::node::operation::BinOp::Ne => Self::Ne,
+            hashql_hir::node::operation::BinOp::Lt => Self::Lt,
+            hashql_hir::node::operation::BinOp::Lte => Self::Lte,
+            hashql_hir::node::operation::BinOp::Gt => Self::Gt,
+            hashql_hir::node::operation::BinOp::Gte => Self::Gte,
+        }
+    }
+}
+
 /// A binary operation in the HashQL MIR.
 ///
 /// Binary operations represent computations that take two input operands and

libs/@local/hashql/mir/src/body/rvalue/mod.rs

@@ -13,7 +13,7 @@ mod unary;
 pub use self::{
     aggregate::{Aggregate, AggregateKind},
     apply::{Apply, ArgIndex},
-    binary::Binary,
+    binary::{BinOp, Binary},
     input::Input,
     unary::Unary,
 };

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

@@ -46,7 +46,7 @@ use hashql_core::{
     r#type::{TypeId, builder::IntoSymbol},
     value::{Float, Primitive},
 };
-use hashql_hir::node::operation::{BinOp, InputOp, UnOp};
+use hashql_hir::node::operation::{InputOp, UnOp};
 
 use crate::{
     body::{
@@ -57,7 +57,7 @@ use crate::{
         local::{Local, LocalDecl, LocalVec},
         operand::Operand,
         place::{FieldIndex, Place, Projection, ProjectionKind},
-        rvalue::{Aggregate, AggregateKind, Apply, Binary, Input, RValue, Unary},
+        rvalue::{Aggregate, AggregateKind, Apply, BinOp, Binary, Input, RValue, Unary},
         statement::{Assign, Statement, StatementKind},
         terminator::{Goto, Return, SwitchInt, SwitchTargets, Target, Terminator, TerminatorKind},
     },
@@ -102,7 +102,7 @@ macro_rules! scaffold {
 /// Comparison and logical operators are supported:
 ///
 /// ```
-/// use hashql_hir::node::operation::BinOp;
+/// use hashql_mir::body::rvalue::BinOp;
 /// use hashql_mir::op;
 ///
 /// // Comparison
@@ -114,8 +114,8 @@ macro_rules! scaffold {
 /// assert!(matches!(op![>=], BinOp::Gte));
 ///
 /// // Logical
-/// assert!(matches!(op![&&], BinOp::And));
-/// assert!(matches!(op![||], BinOp::Or));
+/// assert!(matches!(op![&], BinOp::BitAnd));
+/// assert!(matches!(op![|], BinOp::BitOr));
 /// ```
 ///
 /// Arithmetic operators are also available (`op![+]`, `op![-]`, `op![*]`, `op![/]`),
@@ -133,18 +133,18 @@ macro_rules! scaffold {
 #[macro_export]
 macro_rules! op {
     // Binary operators
-    [+] => { hashql_hir::node::operation::BinOp::Add };
-    [-] => { hashql_hir::node::operation::BinOp::Sub };
-    [*] => { hashql_hir::node::operation::BinOp::Mul };
-    [/] => { hashql_hir::node::operation::BinOp::Div };
-    [==] => { hashql_hir::node::operation::BinOp::Eq };
-    [!=] => { hashql_hir::node::operation::BinOp::Ne };
-    [<] => { hashql_hir::node::operation::BinOp::Lt };
-    [<=] => { hashql_hir::node::operation::BinOp::Lte };
-    [>] => { hashql_hir::node::operation::BinOp::Gt };
-    [>=] => { hashql_hir::node::operation::BinOp::Gte };
-    [&&] => { hashql_hir::node::operation::BinOp::And };
-    [||] => { hashql_hir::node::operation::BinOp::Or };
+    [+] => { $crate::body::rvalue::BinOp::Add };
+    [-] => { $crate::body::rvalue::BinOp::Sub };
+    [*] => { $crate::body::rvalue::BinOp::Mul };
+    [/] => { $crate::body::rvalue::BinOp::Div };
+    [==] => { $crate::body::rvalue::BinOp::Eq };
+    [!=] => { $crate::body::rvalue::BinOp::Ne };
+    [<] => { $crate::body::rvalue::BinOp::Lt };
+    [<=] => { $crate::body::rvalue::BinOp::Lte };
+    [>] => { $crate::body::rvalue::BinOp::Gt };
+    [>=] => { $crate::body::rvalue::BinOp::Gte };
+    [&] => { $crate::body::rvalue::BinOp::BitAnd };
+    [|] => { $crate::body::rvalue::BinOp::BitOr };
 
     // Unary operators
     [!] => { hashql_hir::node::operation::UnOp::Not };

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

@@ -136,7 +136,7 @@ impl<'mir, 'heap> Reifier<'_, 'mir, '_, '_, 'heap> {
         let right = self.operand(right);
 
         RValue::Binary(Binary {
-            op: op.value,
+            op: op.value.into(),
             left,
             right,
         })