feat(eval)!: fail when attempting to perform a bitwise operation with a numeric value that cannot be safely converted to i64

Author: eduardosm

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## 0.4.0 (unreleased)
 
+### Breaking
+
+- Performing bitwise operations with numeric values that cannot be safely
+  converted to `i64` will fail.
+
 ### Added
 
 - New language features from Jsonnet 0.21:

rsjsonnet-front/src/report/eval.rs

@@ -375,6 +375,21 @@ pub(crate) fn render_error_kind(
             }
             .render(span_mgr, src_mgr, &mut out);
         }
+        EvalErrorKind::NumberNotBitwiseSafe { span } => {
+            Message {
+                kind: MessageKind::Error,
+                message: "numeric value cannot be safely used for bitwise operation".into(),
+                labels: span
+                    .map(|span| MessageLabel {
+                        kind: LabelKind::Error,
+                        span,
+                        text: String::new(),
+                    })
+                    .into_iter()
+                    .collect(),
+            }
+            .render(span_mgr, src_mgr, &mut out);
+        }
         EvalErrorKind::NumberOverflow { span } => {
             Message {
                 kind: MessageKind::Error,
@@ -550,6 +565,7 @@ pub(crate) fn render_error_kind(
             }
             .render(span_mgr, src_mgr, &mut out);
         }
+
         EvalErrorKind::CompareBooleanInequality => {
             Message {
                 kind: MessageKind::Error,

rsjsonnet-lang/src/program/error.rs

@@ -146,6 +146,9 @@ pub enum EvalErrorKind {
         lhs_type: EvalErrorValueType,
         rhs_type: EvalErrorValueType,
     },
+    NumberNotBitwiseSafe {
+        span: Option<SpanId>,
+    },
     NumberOverflow {
         span: Option<SpanId>,
     },

rsjsonnet-lang/src/program/eval/expr.rs

@@ -760,38 +760,42 @@ impl<'p> Evaluator<'_, 'p> {
                 self.value_stack.push(ValueData::Number(r));
             }
             (ast::BinaryOp::Shl, ValueData::Number(lhs), ValueData::Number(rhs)) => {
-                let lhs = lhs as i64;
+                let lhs = self.safe_f64_to_i64(lhs, span)?;
                 if rhs.is_sign_negative() {
                     return Err(self.report_error(EvalErrorKind::ShiftByNegative { span }));
                 }
-                let rhs = rhs as i64;
-                let r = lhs << (rhs & 63);
+                let rhs = self.safe_f64_to_i64(rhs, span)?;
+                let shift = rhs & 63;
+                let r = lhs << shift;
+                if r >> shift != lhs {
+                    return Err(self.report_error(EvalErrorKind::NumberNotBitwiseSafe { span }));
+                }
                 self.value_stack.push(ValueData::Number(r as f64));
             }
             (ast::BinaryOp::Shr, ValueData::Number(lhs), ValueData::Number(rhs)) => {
-                let lhs = lhs as i64;
+                let lhs = self.safe_f64_to_i64(lhs, span)?;
                 if rhs.is_sign_negative() {
                     return Err(self.report_error(EvalErrorKind::ShiftByNegative { span }));
                 }
-                let rhs = rhs as i64;
+                let rhs = self.safe_f64_to_i64(rhs, span)?;
                 let r = lhs >> (rhs & 63);
                 self.value_stack.push(ValueData::Number(r as f64));
             }
             (ast::BinaryOp::BitwiseAnd, ValueData::Number(lhs), ValueData::Number(rhs)) => {
-                let lhs = lhs as i64;
-                let rhs = rhs as i64;
+                let lhs = self.safe_f64_to_i64(lhs, span)?;
+                let rhs = self.safe_f64_to_i64(rhs, span)?;
                 let r = lhs & rhs;
                 self.value_stack.push(ValueData::Number(r as f64));
             }
             (ast::BinaryOp::BitwiseOr, ValueData::Number(lhs), ValueData::Number(rhs)) => {
-                let lhs = lhs as i64;
-                let rhs = rhs as i64;
+                let lhs = self.safe_f64_to_i64(lhs, span)?;
+                let rhs = self.safe_f64_to_i64(rhs, span)?;
                 let r = lhs | rhs;
                 self.value_stack.push(ValueData::Number(r as f64));
             }
             (ast::BinaryOp::BitwiseXor, ValueData::Number(lhs), ValueData::Number(rhs)) => {
-                let lhs = lhs as i64;
-                let rhs = rhs as i64;
+                let lhs = self.safe_f64_to_i64(lhs, span)?;
+                let rhs = self.safe_f64_to_i64(rhs, span)?;
                 let r = lhs ^ rhs;
                 self.value_stack.push(ValueData::Number(r as f64));
             }

rsjsonnet-lang/src/program/eval/mod.rs

@@ -886,7 +886,7 @@ impl<'p, 'a> Evaluator<'a, 'p> {
                             self.value_stack.push(ValueData::Number(rhs));
                         }
                         (ast::UnaryOp::BitwiseNot, ValueData::Number(rhs)) => {
-                            let int = rhs as i64;
+                            let int = self.safe_f64_to_i64(rhs, Some(span))?;
                             self.value_stack.push(ValueData::Number(!int as f64));
                         }
                         (ast::UnaryOp::LogicNot, ValueData::Bool(rhs)) => {
@@ -1646,6 +1646,17 @@ impl<'p, 'a> Evaluator<'a, 'p> {
         }
     }
 
+    fn safe_f64_to_i64(&mut self, value: f64, span: Option<SpanId>) -> EvalResult<i64> {
+        let max = (1u64 << 53) as f64;
+        let min = -max;
+
+        if value < min || value > max {
+            Err(self.report_error(EvalErrorKind::NumberNotBitwiseSafe { span }))
+        } else {
+            Ok(value as i64)
+        }
+    }
+
     fn check_number_value(&mut self, value: f64, span: Option<SpanId>) -> EvalResult<()> {
         match value.classify() {
             std::num::FpCategory::Nan => Err(self.report_error(EvalErrorKind::NumberNan { span })),

ui-tests/fail/binary_op/and_unsafe_lhs.jsonnet

@@ -0,0 +1 @@
+1e50 & 0

ui-tests/fail/binary_op/and_unsafe_lhs.stderr

@@ -0,0 +1,7 @@
+error: numeric value cannot be safely used for bitwise operation
+ --> and_unsafe_lhs.jsonnet:1:1
+  |
+1 | 1e50 & 0
+  | ^^^^^^^^
+note: during top-level value evaluation
+

ui-tests/fail/binary_op/and_unsafe_rhs.jsonnet

@@ -0,0 +1 @@
+0 & 1e50

ui-tests/fail/binary_op/and_unsafe_rhs.stderr

@@ -0,0 +1,7 @@
+error: numeric value cannot be safely used for bitwise operation
+ --> and_unsafe_rhs.jsonnet:1:1
+  |
+1 | 0 & 1e50
+  | ^^^^^^^^
+note: during top-level value evaluation
+

ui-tests/fail/binary_op/or_unsafe_lhs.jsonnet

@@ -0,0 +1 @@
+1e50 | 0