feat: improve SSA type-awareness in EQ and MUL instructions

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

@@ -38,9 +38,9 @@
     Or,
     /// Bitwise xor (^)
     Xor,
     /// Bitshift left (<<)
     Shl,
     /// Bitshift right (>>)
     Shr,
 }
 
@@ -130,6 +130,12 @@
                     let zero = dfg.make_constant(FieldElement::zero(), operand_type);
                     return SimplifyResult::SimplifiedTo(zero);
                 }
+                if dfg.resolve(self.lhs) == dfg.resolve(self.rhs)
+                    && dfg.get_value_max_num_bits(self.lhs) == 1
+                {
+                    // Squaring a boolean value is a noop.
+                    return SimplifyResult::SimplifiedTo(self.lhs);
+                }
             }
             BinaryOp::Div => {
                 if rhs_is_one {
@@ -164,6 +170,36 @@
                     let one = dfg.make_constant(FieldElement::one(), Type::bool());
                     return SimplifyResult::SimplifiedTo(one);
                 }
+
+                if operand_type.is_unsigned() {
+                    // If we're comparing a variable against a constant value which lies outside of the range of
+                    // values which the variable's type can take, we can assume that the equality will be false.
+                    match (lhs, rhs) {
+                        (Some(lhs), None) => {
+                            let max_possible_value =
+                                2u128.pow(dfg.get_value_max_num_bits(self.rhs)) - 1;
+                            if lhs > max_possible_value.into() {
+                                let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
+                                return SimplifyResult::SimplifiedTo(zero);
+                            }
+                        }
+
+                        (None, Some(rhs)) => {
+                            let max_possible_value =
+                                2u128.pow(dfg.get_value_max_num_bits(self.lhs)) - 1;
+                            if rhs > max_possible_value.into() {
+                                let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
+                                return SimplifyResult::SimplifiedTo(zero);
+                            }
+                        }
+
+                        (None, None) => (),
+                        (Some(_), Some(_)) => {
+                            unreachable!("Constant binary instructions should be handled above")
+                        }
+                    }
+                }
+
                 if operand_type == Type::bool() {
                     // Simplify forms of `(boolean == true)` into `boolean`
                     if lhs_is_one {
@@ -274,7 +310,7 @@
                         return SimplifyResult::SimplifiedTo(zero);
                     }
 
                     // `two_pow_rhs` is limited to be at most `2 ^ {operand_bitsize - 1}` so it fits in `operand_type`.
                     let two_pow_rhs = FieldElement::from(2u128).pow(&rhs_const);
                     let two_pow_rhs = dfg.make_constant(two_pow_rhs, operand_type);
                     return SimplifyResult::SimplifiedToInstruction(Instruction::binary(