fix: don't panic when shifting too much

compiler/noirc_evaluator/Cargo.toml

@@ -20,6 +20,7 @@ fxhash.workspace = true
 iter-extended.workspace = true
 thiserror.workspace = true
 num-bigint = "0.4"
+num-traits.workspace = true
 im.workspace = true
 serde.workspace = true
 serde_json.workspace = true

compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs

@@ -1,4 +1,5 @@
 use acvm::{acir::AcirField, FieldElement};
+use num_traits::ToPrimitive as _;
 use serde::{Deserialize, Serialize};
 
 use super::{
@@ -39,9 +40,9 @@
     Or,
     /// Bitwise xor (^)
     Xor,
     /// Bitshift left (<<)
     Shl,
     /// Bitshift right (>>)
     Shr,
 }
 
@@ -107,7 +108,7 @@
         }
 
         let operator = if lhs_type == NumericType::NativeField {
             // Unchecked operations between fields or bools don't make sense, so we convert those to non-unchecked
             // to reduce noise and confusion in the generated SSA.
             match operator {
                 BinaryOp::Add { unchecked: true } => BinaryOp::Add { unchecked: false },
@@ -116,7 +117,7 @@
                 _ => operator,
             }
         } else if lhs_type == NumericType::bool() {
             // Unchecked mul between bools doesn't make sense, so we convert that to non-unchecked
             if let BinaryOp::Mul { unchecked: true } = operator {
                 BinaryOp::Mul { unchecked: false }
             } else {
@@ -289,7 +290,7 @@
                 }
                 if lhs_type == NumericType::bool() {
                     // Boolean AND is equivalent to multiplication, which is a cheaper operation.
                     // (mul unchecked because these are bools so it doesn't matter really)
                     let instruction =
                         Instruction::binary(BinaryOp::Mul { unchecked: true }, lhs, rhs);
                     return SimplifyResult::SimplifiedToInstruction(instruction);
@@ -574,8 +575,8 @@
             BinaryOp::Xor => |x, y| Some(x ^ y),
             BinaryOp::Eq => |x, y| Some((x == y) as u128),
             BinaryOp::Lt => |x, y| Some((x < y) as u128),
-            BinaryOp::Shl => |x, y| Some(x << y),
-            BinaryOp::Shr => |x, y| Some(x >> y),
+            BinaryOp::Shl => |x, y| y.to_u32().and_then(|y| x.checked_shl(y)),
+            BinaryOp::Shr => |x, y| y.to_u32().and_then(|y| x.checked_shr(y)),
         }
     }
 
@@ -591,8 +592,8 @@
             BinaryOp::Xor => |x, y| Some(x ^ y),
             BinaryOp::Eq => |x, y| Some((x == y) as i128),
             BinaryOp::Lt => |x, y| Some((x < y) as i128),
-            BinaryOp::Shl => |x, y| Some(x << y),
-            BinaryOp::Shr => |x, y| Some(x >> y),
+            BinaryOp::Shl => |x, y| y.to_u32().and_then(|y| x.checked_shl(y)),
+            BinaryOp::Shr => |x, y| y.to_u32().and_then(|y| x.checked_shr(y)),
         }
     }
 
@@ -621,7 +622,7 @@
 
     use super::{
         convert_signed_integer_to_field_element, truncate_field,
-        try_convert_field_element_to_signed_integer,
+        try_convert_field_element_to_signed_integer, BinaryOp,
     };
     use acvm::{AcirField, FieldElement};
     use num_bigint::BigUint;
@@ -645,10 +646,21 @@
 
             let integer_modulus = BigUint::from(2_u128).pow(bit_size);
             let truncated_as_bigint = BigUint::from(input)
                         .modpow(&BigUint::one(), &integer_modulus);
             let truncated_as_bigint = FieldElement::from_be_bytes_reduce(&truncated_as_bigint.to_bytes_be());
             prop_assert_eq!(truncated_as_field, truncated_as_bigint);
         }
+    }
+
+    #[test]
+    fn get_u128_function_shift_works_with_values_larger_than_127() {
+        assert!(BinaryOp::Shr.get_u128_function()(1, 128).is_none());
+        assert!(BinaryOp::Shl.get_u128_function()(1, 128).is_none());
+    }
 
+    #[test]
+    fn get_i128_function_shift_works_with_values_larger_than_127() {
+        assert!(BinaryOp::Shr.get_i128_function()(1, 128).is_none());
+        assert!(BinaryOp::Shl.get_i128_function()(1, 128).is_none());
     }
 }