feat: enable +/-

Author: indietyp

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

@@ -27,14 +27,11 @@
 //! while preserving the semantics of complex primitive types that should not be
 //! evaluated at compile time.
 
-mod int;
-
 use core::fmt;
 
 use hashql_core::value::Primitive;
 
-pub use self::int::{Int, TryFromIntegerError, TryFromPrimitiveError};
-use crate::def::DefId;
+use crate::{def::DefId, interpret::value::Int};
 
 /// A constant value in the HashQL MIR.
 ///

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

@@ -15,9 +15,9 @@ use crate::body::operand::Operand;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum BinOp {
     /// The `+` operator (addition).
-    Add(!),
+    Add,
     /// The `-` operator (subtraction).
-    Sub(!),
+    Sub,
     /// The `*` operator (multiplication).
     Mul(!),
     /// The `/` operator (division).
@@ -56,6 +56,8 @@ impl BinOp {
     #[must_use]
     pub const fn as_str(self) -> &'static str {
         match self {
+            Self::Add => "+",
+            Self::Sub => "-",
             Self::BitAnd => "&",
             Self::BitOr => "|",
             Self::Eq => "==",
@@ -70,6 +72,8 @@ impl BinOp {
     #[must_use]
     pub const fn as_symbol(self) -> Symbol<'static> {
         match self {
+            Self::Add => sym::symbol::add,
+            Self::Sub => sym::symbol::sub,
             Self::BitAnd => sym::symbol::ampersand,
             Self::BitOr => sym::symbol::pipe,
             Self::Eq => sym::symbol::eq,

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

@@ -38,7 +38,7 @@ impl<'env, 'heap> BaseBuilder<'env, 'heap> {
 
     /// Creates an integer constant operand.
     #[must_use]
-    pub fn const_int(self, value: i64) -> Operand<'heap> {
+    pub fn const_int(self, value: i128) -> Operand<'heap> {
         Operand::Constant(Constant::Int(value.into()))
     }
 

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

@@ -21,8 +21,8 @@ impl<'heap> BuildOperand<'heap, f64> for OperandBuilder<'_, 'heap> {
     }
 }
 
-impl<'heap> BuildOperand<'heap, i64> for OperandBuilder<'_, 'heap> {
-    fn build_operand(&self, value: i64) -> Operand<'heap> {
+impl<'heap> BuildOperand<'heap, i128> for OperandBuilder<'_, 'heap> {
+    fn build_operand(&self, value: i128) -> Operand<'heap> {
         self.base.const_int(value)
     }
 }

libs/@local/hashql/mir/src/interpret/error.rs

@@ -18,9 +18,8 @@ use hashql_diagnostics::{
 };
 use hashql_hir::node::operation::UnOp;
 
-use super::value::{Ptr, Value, ValueTypeName};
+use super::value::{Int, Ptr, Value, ValueTypeName};
 use crate::body::{
-    constant::Int,
     local::{Local, LocalDecl},
     place::FieldIndex,
     rvalue::BinOp,

libs/@local/hashql/mir/src/interpret/locals.rs

@@ -396,13 +396,16 @@ mod tests {
     use super::Locals;
     use crate::{
         body::{
-            constant::{Constant, Int},
+            constant::Constant,
             local::{Local, LocalDecl, LocalSlice, LocalVec},
             operand::Operand,
             place::{FieldIndex, Place},
         },
         intern::Interner,
-        interpret::{error::RuntimeError, value::Value},
+        interpret::{
+            error::RuntimeError,
+            value::{Int, Value},
+        },
     };
 
     fn fill_decl(decl: &mut LocalVec<LocalDecl<'_>>, max_index: Local) {

libs/@local/hashql/mir/src/interpret/runtime.rs

@@ -324,6 +324,40 @@ impl<'ctx, 'heap, A: Allocator + Clone> Runtime<'ctx, 'heap, A> {
         let rhs = frame.locals.operand(right)?;
 
         let value = match op {
+            BinOp::Add => {
+                return match (lhs.as_ref(), rhs.as_ref()) {
+                    (Value::Integer(lhs), Value::Integer(rhs)) => Ok(Value::from(lhs + rhs)),
+                    (Value::Integer(lhs), Value::Number(rhs)) => Ok(Value::Number(lhs + rhs)),
+                    (Value::Number(lhs), Value::Integer(rhs)) => Ok(Value::Number(lhs + rhs)),
+                    (Value::Number(lhs), Value::Number(rhs)) => Ok(Value::Number(lhs + rhs)),
+                    _ => Err(RuntimeError::BinaryTypeMismatch(Box::new(
+                        BinaryTypeMismatch {
+                            op,
+                            lhs_expected: TypeName::terse("Number"),
+                            rhs_expected: TypeName::terse("Number"),
+                            lhs: lhs.into_owned(),
+                            rhs: rhs.into_owned(),
+                        },
+                    ))),
+                };
+            }
+            BinOp::Sub => {
+                return match (lhs.as_ref(), rhs.as_ref()) {
+                    (Value::Integer(lhs), Value::Integer(rhs)) => Ok(Value::from(lhs - rhs)),
+                    (Value::Integer(lhs), Value::Number(rhs)) => Ok(Value::Number(lhs - rhs)),
+                    (Value::Number(lhs), Value::Integer(rhs)) => Ok(Value::Number(lhs - rhs)),
+                    (Value::Number(lhs), Value::Number(rhs)) => Ok(Value::Number(lhs - rhs)),
+                    _ => Err(RuntimeError::BinaryTypeMismatch(Box::new(
+                        BinaryTypeMismatch {
+                            op,
+                            lhs_expected: TypeName::terse("Number"),
+                            rhs_expected: TypeName::terse("Number"),
+                            lhs: lhs.into_owned(),
+                            rhs: rhs.into_owned(),
+                        },
+                    ))),
+                };
+            }
             BinOp::BitAnd => {
                 return match (lhs.as_ref(), rhs.as_ref()) {
                     (Value::Integer(lhs), Value::Integer(rhs)) => Ok(Value::Integer(lhs & rhs)),

libs/@local/hashql/mir/src/interpret/tests.rs

@@ -22,11 +22,15 @@ use hashql_core::{
     r#type::{TypeId, environment::Environment},
 };
 
-use super::{CallStack, Runtime, RuntimeConfig, error::InterpretDiagnostic, value::Value};
+use super::{
+    CallStack, Runtime, RuntimeConfig,
+    error::InterpretDiagnostic,
+    value::{Int, Value},
+};
 use crate::{
     body::{
         Body,
-        constant::{Constant, Int},
+        constant::Constant,
         operand::Operand,
         rvalue::{Aggregate, AggregateKind, RValue},
     },

…ocal/hashql/mir/src/body/constant/int.rs …al/hashql/mir/src/interpret/value/int.rslibs/@local/hashql/mir/src/body/constant/int.rs renamed to libs/@local/hashql/mir/src/interpret/value/int.rs libs/@local/hashql/mir/src/body/constant/int.rs renamed to libs/@local/hashql/mir/src/interpret/value/int.rs

@@ -2,7 +2,7 @@ use core::{
     error::Error,
     fmt::{self, Display},
     num::TryFromIntError,
-    ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Neg, Not},
+    ops::{Add, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Neg, Not, Sub},
 };
 
 use hashql_core::value::{Integer, Primitive};
@@ -642,6 +642,58 @@ impl Neg for Int {
     }
 }
 
+impl Add for Int {
+    type Output = Numeric;
+
+    #[inline]
+    #[expect(clippy::float_arithmetic)]
+    fn add(self, rhs: Self) -> Self::Output {
+        let (value, overflow) = self.as_int().overflowing_add(rhs.as_int());
+
+        if overflow {
+            Numeric::Num(Num::from(self.as_f64() + rhs.as_f64()))
+        } else {
+            Numeric::Int(Self::from_value_unchecked(value))
+        }
+    }
+}
+
+impl Add<Num> for Int {
+    type Output = Num;
+
+    #[inline]
+    #[expect(clippy::float_arithmetic)]
+    fn add(self, rhs: Num) -> Self::Output {
+        Num::from(self.as_f64() + rhs.as_f64())
+    }
+}
+
+impl Sub for Int {
+    type Output = Numeric;
+
+    #[inline]
+    #[expect(clippy::float_arithmetic)]
+    fn sub(self, rhs: Self) -> Self::Output {
+        let (value, overflow) = self.as_int().overflowing_sub(rhs.as_int());
+
+        if overflow {
+            Numeric::Num(Num::from(self.as_f64() - rhs.as_f64()))
+        } else {
+            Numeric::Int(Self::from_value_unchecked(value))
+        }
+    }
+}
+
+impl Sub<Num> for Int {
+    type Output = Num;
+
+    #[inline]
+    #[expect(clippy::float_arithmetic)]
+    fn sub(self, rhs: Num) -> Self::Output {
+        Num::from(self.as_f64() - rhs.as_f64())
+    }
+}
+
 impl BitOr for Int {
     type Output = Self;
 
@@ -692,6 +744,10 @@ impl BitXorAssign for Int {
 
 forward_ref_unop!(impl Not::not for Int);
 forward_ref_unop!(impl Neg::neg for Int);
+forward_ref_binop!(impl Add<Int>::add for Int);
+forward_ref_binop!(impl Add<Num>::add for Int);
+forward_ref_binop!(impl Sub<Int>::sub for Int);
+forward_ref_binop!(impl Sub<Num>::sub for Int);
 forward_ref_binop!(impl BitOr<Int>::bitor for Int);
 forward_ref_binop!(impl BitAnd<Int>::bitand for Int);
 forward_ref_binop!(impl BitXor<Int>::bitxor for Int);
@@ -707,7 +763,7 @@ mod tests {
         clippy::float_cmp
     )]
 
-    use crate::{body::constant::Int, interpret::value::Numeric};
+    use crate::interpret::value::{Int, Numeric};
 
     #[test]
     fn neg_positive() {

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

@@ -4,8 +4,7 @@ use core::{alloc::Allocator, cmp, iter::FusedIterator};
 
 use imbl::shared_ptr::RcK;
 
-use super::Value;
-use crate::body::constant::Int;
+use super::{Int, Value};
 
 /// An ordered list of values.
 #[derive(Debug, Clone)]