fix: use predicate expression as binary result

compiler/noirc_evaluator/src/acir/acir_context/mod.rs

@@ -1183,12 +1183,13 @@ impl<F: AcirField, B: BlackBoxFunctionSolver<F>> AcirContext<F, B> {
                         .assertion_payloads
                         .insert(self.acir_ir.last_acir_opcode_location(), payload);
                 }
+                Ok(predicate_range)
             }
             NumericType::NativeField => {
                 // Range constraining a Field is a no-op
+                Ok(variable)
             }
         }
-        Ok(variable)
     }
 
     /// Returns an `AcirVar` which will be constrained to be lhs mod 2^{rhs}

compiler/noirc_evaluator/src/acir/mod.rs

@@ -1067,10 +1067,10 @@ impl<'a> Context<'a> {
 
         if let NumericType::Unsigned { bit_size } = &num_type {
             // Check for integer overflow
-            self.check_unsigned_overflow(result, *bit_size, binary, predicate)?;
+            self.check_unsigned_overflow(result, *bit_size, binary, predicate)
+        } else {
+            Ok(result)
         }
-
-        Ok(result)
     }
 
     /// Adds a range check against the bit size of the result of addition, subtraction or multiplication
@@ -1080,21 +1080,20 @@ impl<'a> Context<'a> {
         bit_size: u32,
         binary: &Binary,
         predicate: AcirVar,
-    ) -> Result<(), RuntimeError> {
+    ) -> Result<AcirVar, RuntimeError> {
         let msg = match binary.operator {
             BinaryOp::Add { unchecked: false } => "attempt to add with overflow",
             BinaryOp::Sub { unchecked: false } => "attempt to subtract with overflow",
             BinaryOp::Mul { unchecked: false } => "attempt to multiply with overflow",
-            _ => return Ok(()),
+            _ => return Ok(result),
         };
 
         self.acir_context.range_constrain_var(
             result,
             &NumericType::Unsigned { bit_size },
             Some(msg.to_string()),
             predicate,
-        )?;
-        Ok(())
+        )
     }
 
     /// Operands in a binary operation are checked to have the same type.

test_programs/execution_success/regression_8558/Nargo.toml

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

test_programs/execution_success/regression_8558/Prover.toml

@@ -0,0 +1,2 @@
+v1 = 0
+v2 = false

test_programs/execution_success/regression_8558/src/main.nr

@@ -0,0 +1,7 @@
+fn main(v1: u16, v2: bool) -> pub u8 {
+    if v2 {
+        (v1 - 257) as u8
+    } else {
+        0
+    }
+}

test_programs/execution_success/regression_8558/stdout.txt

@@ -0,0 +1 @@
+[regression_8558] Circuit output: Field(0)