fix: prevent incorrect ACIRgen caused by noop truncations

compiler/noirc_evaluator/src/acir/acir_variable.rs

@@ -842,18 +842,19 @@ impl<F: AcirField, B: BlackBoxFunctionSolver<F>> AcirContext<F, B> {
         }
 
         // maximum bit size for q and for [r and rhs]
-        let mut max_q_bits = bit_size;
-        let mut max_rhs_bits = bit_size;
-        // when rhs is constant, we can better estimate the maximum bit sizes
-        if let Some(rhs_const) = rhs_expr.to_const() {
-            max_rhs_bits = rhs_const.num_bits();
-            if max_rhs_bits != 0 {
-                if max_rhs_bits > bit_size {
-                    return Ok((zero, zero));
-                }
-                max_q_bits = bit_size - max_rhs_bits + 1;
-            }
-        }
+        let (max_q_bits, max_rhs_bits) = if let Some(rhs_const) = rhs_expr.to_const() {
+            // when rhs is constant, we can better estimate the maximum bit sizes
+            let max_rhs_bits = rhs_const.num_bits();
+            assert!(
+                max_rhs_bits <= bit_size,
+                "attempted to divide by constant larger than operand type"
+            );
+
+            let max_q_bits = bit_size - max_rhs_bits + 1;
+            (max_q_bits, max_rhs_bits)
+        } else {
+            (bit_size, bit_size)
+        };
 
         let [q_value, r_value]: [AcirValue; 2] = self
             .brillig_call(

compiler/noirc_evaluator/src/acir/mod.rs

@@ -2094,6 +2094,12 @@ impl<'a> Context<'a> {
         max_bit_size: u32,
         dfg: &DataFlowGraph,
     ) -> Result<AcirVar, RuntimeError> {
+        assert_ne!(bit_size, max_bit_size, "Attempted to generate a noop truncation");
+        assert!(
+            bit_size < max_bit_size,
+            "Attempted to generate a truncation into large size than max input"
+        );
+
         let mut var = self.convert_numeric_value(value_id, dfg)?;
         match &dfg[value_id] {
             Value::Instruction { instruction, .. } => {

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

@@ -39,9 +39,9 @@
     Or,
     /// Bitwise xor (^)
     Xor,
     /// Bitshift left (<<)
     Shl,
     /// Bitshift right (>>)
     Shr,
 }
 
@@ -107,7 +107,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 +116,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 +289,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);
@@ -306,14 +306,18 @@
                             let bitmask_plus_one = bitmask.to_u128() + 1;
                             if bitmask_plus_one.is_power_of_two() {
                                 let value = if lhs_value.is_some() { rhs } else { lhs };
-                                let num_bits = bitmask_plus_one.ilog2();
-                                return SimplifyResult::SimplifiedToInstruction(
-                                    Instruction::Truncate {
-                                        value,
-                                        bit_size: num_bits,
-                                        max_bit_size: lhs_type.bit_size(),
-                                    },
-                                );
+                                let bit_size = bitmask_plus_one.ilog2();
+                                let max_bit_size = lhs_type.bit_size();
+
+                                if bit_size == max_bit_size {
+                                    // If we're truncating a value into the full size of its type then
+                                    // the truncation is a noop.
+                                    return SimplifyResult::SimplifiedTo(value);
+                                } else {
+                                    return SimplifyResult::SimplifiedToInstruction(
+                                        Instruction::Truncate { value, bit_size, max_bit_size },
+                                    );
+                                }
                             }
                         }
 
@@ -645,7 +649,7 @@
 
             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);
         }

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

@@ -204,4 +204,26 @@ mod tests {
         ";
         assert_normalized_ssa_equals(ssa, expected);
     }
+
+    #[test]
+    fn simplifies_out_noop_bitwise_ands() {
+        // Regression test for https://github.com/noir-lang/noir/issues/7451
+        let src = "
+        acir(inline) predicate_pure fn main f0 {
+        b0(v0: u8):
+            v1 = and u8 255, v0
+            return v1
+        }
+        ";
+
+        let ssa = Ssa::from_str_simplifying(src).unwrap();
+
+        let expected = "
+        acir(inline) fn main f0 {
+        b0(v0: u8):
+            return v0
+        }
+        ";
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 }

test_programs/execution_success/regression_7451/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_7451"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/regression_7451/Prover.toml

@@ -0,0 +1 @@
+x="1"

test_programs/execution_success/regression_7451/src/main.nr

@@ -0,0 +1,12 @@
+fn main(x: u8) {
+    // Safety: test code
+    let predicate = unsafe { return_true() };
+    let tmp: u8 = if predicate { 0xff } else { 0 };
+
+    let y = tmp & x;
+    assert_eq(y, 1);
+}
+
+unconstrained fn return_true() -> bool {
+    true
+}