fix: proper cleanup when breaking from comptime loop on error (#7125)

noir-lang · Jan 21, 2025 · bf32a22 · bf32a22 · github-actions · Jan 21, 2025
1 parent ed9977a
commit bf32a22
Showing 1 changed file with 33 additions and 15 deletions.
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -1724,50 +1724,68 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         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));
 
-            match self.evaluate(for_.block) {
-                Ok(_) => (),
-                Err(InterpreterError::Break) => break,
-                Err(InterpreterError::Continue) => continue,
-                Err(other) => return Err(other),
-            }
+            let must_break = match self.evaluate(for_.block) {
+                Ok(_) => false,
+                Err(InterpreterError::Break) => true,
+                Err(InterpreterError::Continue) => false,
+                Err(error) => {
+                    result = Err(error);
+                    true
+                }
+            };
 
             self.pop_scope();
+
+            if must_break {
+                break;
+            }
         }
 
         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();
 
-            match self.evaluate(expr) {
-                Ok(_) => (),
-                Err(InterpreterError::Break) => break,
-                Err(InterpreterError::Continue) => continue,
-                Err(other) => return Err(other),
-            }
+            let must_break = match self.evaluate(expr) {
+                Ok(_) => false,
+                Err(InterpreterError::Break) => true,
+                Err(InterpreterError::Continue) => false,
+                Err(error) => {
+                    result = Err(error);
+                    true
+                }
+            };
 
             self.pop_scope();
 
+            if must_break {
+                break;
+            }
+
             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> {