fix: proper cleanup when breaking from comptime loop on error

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -258,7 +258,7 @@
             }
         } else {
             let name = self.elaborator.interner.function_name(&function);
             unreachable!("Non-builtin, lowlevel or oracle builtin fn '{name}'")
         }
     }
 
@@ -1052,7 +1052,7 @@
         }
 
         /// Generate matches for bit shifting, which in Noir only accepts `u8` for RHS.
         macro_rules! match_bitshift {
             (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => {
                 match_values! {
                     ($lhs_value as $lhs $op $rhs_value as $rhs) {
@@ -1122,10 +1122,10 @@
             BinaryOpKind::Xor => match_bitwise! {
                 (lhs_value as lhs "^" rhs_value as rhs) => lhs ^ rhs
             },
             BinaryOpKind::ShiftRight => match_bitshift! {
                 (lhs_value as lhs ">>" rhs_value as rhs) => lhs.checked_shr(rhs.into())
             },
             BinaryOpKind::ShiftLeft => match_bitshift! {
                 (lhs_value as lhs "<<" rhs_value as rhs) => lhs.checked_shl(rhs.into())
             },
             BinaryOpKind::Modulo => match_integer! {
@@ -1724,6 +1724,8 @@
         let (end, _) = get_index(self, for_.end_range)?;
         let was_in_loop = std::mem::replace(&mut self.in_loop, true);
 
+        let mut result = Ok(Value::Unit);
+
         for i in start..end {
             self.push_scope();
             self.current_scope_mut().insert(for_.identifier.id, make_value(i));
@@ -1732,20 +1734,24 @@
                 Ok(_) => (),
                 Err(InterpreterError::Break) => break,
                 Err(InterpreterError::Continue) => continue,
-                Err(other) => return Err(other),
+                Err(error) => {
+                    result = Err(error);
+                    break;
+                }
             }
 
             self.pop_scope();
         }
 
         self.in_loop = was_in_loop;
-        Ok(Value::Unit)
+        result
     }
 
     fn evaluate_loop(&mut self, expr: ExprId) -> IResult<Value> {
         let was_in_loop = std::mem::replace(&mut self.in_loop, true);
         let in_lsp = self.elaborator.interner.is_in_lsp_mode();
         let mut counter = 0;
+        let mut result = Ok(Value::Unit);
 
         loop {
             self.push_scope();
@@ -1754,20 +1760,24 @@
                 Ok(_) => (),
                 Err(InterpreterError::Break) => break,
                 Err(InterpreterError::Continue) => continue,
-                Err(other) => return Err(other),
+                Err(error) => {
+                    result = Err(error);
+                    break;
+                }
             }
 
             self.pop_scope();
 
             counter += 1;
             if in_lsp && counter == 10_000 {
                 let location = self.elaborator.interner.expr_location(&expr);
-                return Err(InterpreterError::LoopHaltedForUiResponsiveness { location });
+                result = Err(InterpreterError::LoopHaltedForUiResponsiveness { location });
+                break;
             }
         }
 
         self.in_loop = was_in_loop;
-        Ok(Value::Unit)
+        result
     }
 
     fn evaluate_break(&mut self, id: StmtId) -> IResult<Value> {