feat: mark division/modulo by constants as not requiring a predicate

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

@@ -407,7 +407,7 @@
             // These can fail.
             Constrain(..) | RangeCheck { .. } => true,
 
             // This should never be side-effectful
             MakeArray { .. } | Noop => false,
 
             // Some binary math can overflow or underflow
@@ -507,11 +507,10 @@
         match self {
             Binary(binary) => {
                 if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
-                    if let Some(rhs) = function.dfg.get_numeric_constant(binary.rhs) {
-                        rhs != FieldElement::zero()
-                    } else {
-                        false
-                    }
+                    function
+                        .dfg
+                        .get_numeric_constant(binary.rhs)
+                        .map_or(false, |rhs| !rhs.is_zero())
                 } else {
                     true
                 }
@@ -571,11 +570,13 @@
         match self {
             Instruction::Binary(binary) => {
                 match binary.operator {
+                    BinaryOp::Div | BinaryOp::Mod => {
+                        // Division and modulo operations can fail if the RHS is zero but is otherwise safe.
+                        dfg.get_numeric_constant(binary.rhs).map_or(false, |rhs| !rhs.is_zero())
+                    }
                     BinaryOp::Add { unchecked: false }
                     | BinaryOp::Sub { unchecked: false }
-                    | BinaryOp::Mul { unchecked: false }
-                    | BinaryOp::Div
-                    | BinaryOp::Mod => {
+                    | BinaryOp::Mul { unchecked: false } => {
                         // Some binary math can overflow or underflow, but this is only the case
                         // for unsigned types (here we assume the type of binary.lhs is the same)
                         dfg.type_of_value(binary.rhs).is_unsigned()