From 597f86ff2e654c2dc1600e4aa2dbbdf20e862dc9 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Wed, 26 Nov 2025 17:49:13 +0000
Subject: [PATCH 01/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs   | 185 +++++++++++++++++-
 .../src/b_compile_intermediate.rs             |  96 +++++----
 crates/lean_compiler/src/grammar.pest         |   3 +
 crates/lean_compiler/src/lang.rs              |  29 ++-
 .../src/parser/parsers/statement.rs           |  12 ++
 .../recursion_program.lean_lang               |  13 +-
 6 files changed, 289 insertions(+), 49 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index 4a7fc1b6..b23b01b4 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -3,7 +3,7 @@ use crate::{
     ir::HighLevelOperation,
     lang::{
         AssumeBoolean, Boolean, Condition, ConstExpression, ConstMallocLabel, ConstantValue, Expression, Function,
-        Line, Program, SimpleExpr, Var,
+        Line, Program, SimpleExpr, Var, Context, Scope,
     },
 };
 use lean_vm::{SourceLineNumber, Table, TableT};
@@ -72,6 +72,7 @@ pub enum SimpleLine {
         value: SimpleExpr,
         arms: Vec<Vec<Self>>, // patterns = 0, 1, ...
     },
+    ForwardDeclaration { var: Var },
     Assignment {
         var: VarOrConstMallocAccess,
         operation: HighLevelOperation,
@@ -150,6 +151,7 @@ pub enum SimpleLine {
 }
 
 pub fn simplify_program(mut program: Program) -> SimpleProgram {
+    check_program_scoping(&program);
     handle_inlined_functions(&mut program);
     handle_const_arguments(&mut program);
     let mut new_functions = BTreeMap::new();
@@ -189,6 +191,168 @@ pub fn simplify_program(mut program: Program) -> SimpleProgram {
     }
 }
 
+/// Analyzes the program to verify that each variable is defined in each context where it is used.
+fn check_program_scoping(program: &Program)  {
+    for (_, function) in program.functions.iter() {
+        let mut scope = Scope { vars: BTreeSet::new() };
+        for (arg, _) in function.arguments.iter() {
+            scope.vars.insert(arg.clone());
+        }
+        let mut ctx = Context { scopes: vec![scope] };
+
+        check_block_scoping(&function.body, &mut ctx);
+    }
+}
+
+/// Analyzes the block to verify that each variable is defined in each context where it is used.
+fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
+    for line in block.iter() {
+        match line {
+            Line::ForwardDeclaration { var } => {
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                last_scope.vars.insert(var.clone());
+            },
+            Line::Match { value, arms } => {
+                check_expr_scoping(value, ctx);
+                for (_, arm) in arms {
+                    ctx.scopes.push(Scope { vars: BTreeSet::new() });
+                    check_block_scoping(arm, ctx);
+                    ctx.scopes.pop();
+                }
+            },
+            Line::Assignment { var, value } => {
+                check_expr_scoping(value, ctx);
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                last_scope.vars.insert(var.clone());
+              },
+            Line::ArrayAssign { array, index, value } => {
+                check_simple_expr_scoping(array, ctx);
+                check_expr_scoping(index, ctx);
+                check_expr_scoping(value, ctx);
+            },
+            Line::Assert(boolean, _) => {
+                check_boolean_scoping(boolean, ctx);
+            },
+            Line::IfCondition { condition, then_branch, else_branch, line_number: _ } => {
+                check_condition_scoping(condition, ctx);
+                for branch in [then_branch, else_branch] {
+                    ctx.scopes.push(Scope { vars: BTreeSet::new() });
+                    check_block_scoping(branch, ctx);
+                    ctx.scopes.pop();
+                }
+            },
+            Line::ForLoop { iterator, start, end, body, rev: _, unroll: _, line_number: _ } => {
+                check_expr_scoping(start, ctx);
+                check_expr_scoping(end, ctx);
+                let mut new_scope_vars = BTreeSet::new();
+                new_scope_vars.insert(iterator.clone());
+                ctx.scopes.push(Scope { vars: new_scope_vars });
+                check_block_scoping(body, ctx);
+                ctx.scopes.pop();
+            },
+            Line::FunctionCall { function_name: _, args, return_data, line_number: _ } => {
+                for arg in args {
+                    check_expr_scoping(arg, ctx);
+                }
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                for var in return_data {
+                    assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                    last_scope.vars.insert(var.clone());
+                }
+            },
+            Line::FunctionRet { return_data } => {
+                for expr in return_data {
+                    check_expr_scoping(expr, ctx);
+                }
+            },
+            Line::Precompile { table: _, args } => {
+                for arg in args {
+                    check_expr_scoping(arg, ctx);
+                }
+            },
+            Line::Break | Line::Panic | Line::LocationReport { .. } => {},
+            Line::Print { line_info: _, content } => {
+                for expr in content {
+                    check_expr_scoping(expr, ctx);
+                }
+            },
+            Line::MAlloc { var, size, vectorized: _, vectorized_len } => {
+                check_expr_scoping(size, ctx);
+                check_expr_scoping(vectorized_len, ctx);
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                last_scope.vars.insert(var.clone());
+            },
+            Line::DecomposeBits { var, to_decompose } | Line::DecomposeCustom { var, to_decompose } => {
+                for expr in to_decompose {
+                    check_expr_scoping(expr, ctx);
+                }
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                last_scope.vars.insert(var.clone());
+            },
+            Line::CounterHint { var } => {
+                let last_scope = ctx.scopes.last_mut().unwrap();
+                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                last_scope.vars.insert(var.clone());
+            },
+        }
+    }
+}
+
+/// Analyzes the expression to verify that each variable is defined in the given context.
+fn check_expr_scoping(expr: &Expression, ctx: &Context) {
+    match expr {
+        Expression::Value(simple_expr) => {
+            check_simple_expr_scoping(simple_expr, ctx);
+        },
+        Expression::ArrayAccess { array, index } => {
+            check_simple_expr_scoping(array, ctx);
+            check_expr_scoping(&*index, ctx);
+        },
+        Expression::Binary { left, operation: _, right } => {
+            check_expr_scoping(&*left, ctx);
+            check_expr_scoping(&*right, ctx);
+        },
+        Expression::Log2Ceil { value } => {
+            check_expr_scoping(&*value, ctx);
+        },
+    }
+}
+
+/// Analyzes the simple expression to verify that each variable is defined in the given context.
+fn check_simple_expr_scoping(expr: &SimpleExpr, ctx: &Context) {
+    match expr {
+        SimpleExpr::Var(v) => {
+            assert!(ctx.defines(&v), "Variable defined but not used: {:?}", v)
+        },
+        SimpleExpr::Constant(_) => {},
+        SimpleExpr::ConstMallocAccess { .. } => {},
+    }
+}
+
+fn check_boolean_scoping(boolean: &Boolean, ctx: &Context) {
+    match boolean {
+        Boolean::Equal { left, right } | Boolean::Different { left, right } => {
+            check_expr_scoping(left, ctx);
+            check_expr_scoping(right, ctx);
+        },
+    }
+}
+
+fn check_condition_scoping(condition: &Condition, ctx: &Context) {
+    match condition {
+        Condition::Expression(expr, _) => {
+            check_expr_scoping(expr, ctx);
+        },
+        Condition::Comparison(boolean) => {
+            check_boolean_scoping(boolean, ctx);
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 struct Counters {
     aux_vars: usize,
@@ -233,6 +397,9 @@ fn simplify_lines(
     let mut res = Vec::new();
     for line in lines {
         match line {
+            Line::ForwardDeclaration { var: _ } => {
+                todo!();
+            },
             Line::Match { value, arms } => {
                 let simple_value = simplify_expr(value, &mut res, counters, array_manager, const_malloc);
                 let mut simple_arms = vec![];
@@ -782,6 +949,10 @@ pub fn find_variable_usage(lines: &[Line]) -> (BTreeSet<Var>, BTreeSet<Var>) {
 
     for line in lines {
         match line {
+            Line::ForwardDeclaration { var: _ } => {
+                todo!();
+                // internal_vars.push(var.clone()); // if declaring is using; otherwise do nothing
+            },
             Line::Match { value, arms } => {
                 on_new_expr(value, &internal_vars, &mut external_vars);
                 for (_, statements) in arms {
@@ -927,7 +1098,7 @@ pub fn inline_lines(lines: &mut Vec<Line>, args: &BTreeMap<Var, SimpleExpr>, res
     let inline_internal_var = |var: &mut Var| {
         assert!(
             !args.contains_key(var),
-            "Variable {var} is both an argument and assigned in the inlined function"
+            "Variable {var} is both an argument and declared in the inlined function"
         );
         *var = format!("@inlined_var_{inlining_count}_{var}");
     };
@@ -935,6 +1106,9 @@ pub fn inline_lines(lines: &mut Vec<Line>, args: &BTreeMap<Var, SimpleExpr>, res
     let mut lines_to_replace = vec![];
     for (i, line) in lines.iter_mut().enumerate() {
         match line {
+            Line::ForwardDeclaration { var } => {
+                inline_internal_var(var);
+            }
             Line::Match { value, arms } => {
                 inline_expr(value, args, inlining_count);
                 for (_, statements) in arms {
@@ -1240,6 +1414,9 @@ fn replace_vars_for_unroll(
                     replace_vars_for_unroll(statements, iterator, unroll_index, iterator_value, internal_vars);
                 }
             }
+            Line::ForwardDeclaration { var } => {
+                *var = format!("@unrolled_{unroll_index}_{iterator_value}_{var}");
+            }
             Line::Assignment { var, value } => {
                 assert!(var != iterator, "Weird");
                 *var = format!("@unrolled_{unroll_index}_{iterator_value}_{var}");
@@ -1689,6 +1866,7 @@ fn get_function_called(lines: &[Line], function_called: &mut Vec<String>) {
                 get_function_called(body, function_called);
             }
             Line::Assignment { .. }
+            | Line::ForwardDeclaration { .. }
             | Line::ArrayAssign { .. }
             | Line::Assert { .. }
             | Line::FunctionRet { .. }
@@ -1714,6 +1892,9 @@ fn replace_vars_by_const_in_lines(lines: &mut [Line], map: &BTreeMap<Var, F>) {
                     replace_vars_by_const_in_lines(statements, map);
                 }
             }
+            Line::ForwardDeclaration { var } => {
+                assert!(!map.contains_key(var), "Variable {var} is a constant");
+            }
             Line::Assignment { var, value } => {
                 assert!(!map.contains_key(var), "Variable {var} is a constant");
                 replace_vars_by_const_in_expr(value, map);
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index e77ac8ae..e2ffb82e 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -14,31 +14,45 @@ struct Compiler {
     if_counter: usize,
     call_counter: usize,
     func_name: String,
-    var_positions: BTreeMap<Var, usize>, // var -> memory offset from fp
+    stack_frame_layout: StackFrameLayout,
     args_count: usize,
     stack_size: usize,
+}
+
+struct StackFrameLayout {
+    // Innermost lexical scope last
+    scopes: Vec<ScopeLayout>,
+}
+
+#[derive(Default)]
+struct ScopeLayout {
+    var_positions: BTreeMap<Var, usize>, // var -> memory offset from fp
     const_mallocs: BTreeMap<ConstMallocLabel, usize>, // const_malloc_label -> start = memory offset from fp
 }
 
 impl Compiler {
     fn get_offset(&self, var: &VarOrConstMallocAccess) -> ConstExpression {
         match var {
-            VarOrConstMallocAccess::Var(var) => (*self
-                .var_positions
-                .get(var)
-                .unwrap_or_else(|| panic!("Variable {var} not in scope")))
-            .into(),
-            VarOrConstMallocAccess::ConstMallocAccess { malloc_label, offset } => ConstExpression::Binary {
-                left: Box::new(
-                    self.const_mallocs
-                        .get(malloc_label)
-                        .copied()
-                        .unwrap_or_else(|| panic!("Const malloc {malloc_label} not in scope"))
-                        .into(),
-                ),
-                operation: HighLevelOperation::Add,
-                right: Box::new(offset.clone()),
-            },
+            VarOrConstMallocAccess::Var(var) => {
+                for scope in self.stack_frame_layout.scopes.iter().rev() {
+                    if let Some(offset) = scope.var_positions.get(var) {
+                        return offset.into();
+                    }
+                }
+                panic!("Variable {var} not in scope");
+            }
+            VarOrConstMallocAccess::ConstMallocAccess { malloc_label, offset } => {
+                for scope in self.stack_frame_layout.scopes.iter().rev() {
+                    if let Some(base) = scope.const_mallocs.get(malloc_label) {
+                        return ConstExpression::Binary {
+                            left: Box::new(base.into()),
+                            operation: HighLevelOperation::Add,
+                            right: Box::new(offset.clone()),
+                        };
+                    }
+                }
+                panic!("Const malloc {malloc_label} not in scope");
+            }
         }
     }
 }
@@ -68,18 +82,7 @@ impl IntermediateValue {
             },
             SimpleExpr::Constant(c) => Self::Constant(c.clone()),
             SimpleExpr::ConstMallocAccess { malloc_label, offset } => Self::MemoryAfterFp {
-                offset: ConstExpression::Binary {
-                    left: Box::new(
-                        compiler
-                            .const_mallocs
-                            .get(malloc_label)
-                            .copied()
-                            .unwrap_or_else(|| panic!("Const malloc {malloc_label} not in scope"))
-                            .into(),
-                    ),
-                    operation: HighLevelOperation::Add,
-                    right: Box::new(offset.clone()),
-                },
+                offset: compiler.get_offset(SimpleExpr::ConstMallocAccess { malloc_label, offset }),
             },
         }
     }
@@ -110,28 +113,23 @@ fn compile_function(
     function: &SimpleFunction,
     compiler: &mut Compiler,
 ) -> Result<Vec<IntermediateInstruction>, String> {
-    let mut internal_vars = find_internal_vars(&function.instructions);
-
-    internal_vars.retain(|var| !function.arguments.contains(var));
-
     // memory layout: pc, fp, args, return_vars, internal_vars
     let mut stack_pos = 2; // Reserve space for pc and fp
     let mut var_positions = BTreeMap::new();
+    let mut function_scope = Scope::default();
+    compiler.stack_frame_layout = StackFrameLayout {
+        scopes: vec![function_scope],
+    };
+    let function_scope = &mut compiler.stack_frame_layout.scopes[0];
 
     for (i, var) in function.arguments.iter().enumerate() {
-        var_positions.insert(var.clone(), stack_pos + i);
+        function_scope.var_positions.insert(var.clone(), stack_pos + i);
     }
     stack_pos += function.arguments.len();
 
     stack_pos += function.n_returned_vars;
 
-    for (i, var) in internal_vars.iter().enumerate() {
-        var_positions.insert(var.clone(), stack_pos + i);
-    }
-    stack_pos += internal_vars.len();
-
     compiler.func_name = function.name.clone();
-    compiler.var_positions = var_positions;
     compiler.stack_size = stack_pos;
     compiler.args_count = function.arguments.len();
 
@@ -152,16 +150,23 @@ fn compile_lines(
     final_jump: Option<Label>,
     declared_vars: &mut BTreeSet<Var>,
 ) -> Result<Vec<IntermediateInstruction>, String> {
+    // TODO: amend stack frame layout with internal variables.
+
     let mut instructions = Vec::new();
 
     for (i, line) in lines.iter().enumerate() {
         match line {
+            SimpleLine::ForwardDeclaration => {
+                todo!(); // amend stack frame layout
+            }
+
             SimpleLine::Assignment {
                 var,
                 operation,
                 arg0,
                 arg1,
             } => {
+                todo!(); // amend stack frame layout
                 instructions.push(IntermediateInstruction::computation(
                     *operation,
                     IntermediateValue::from_simple_expr(arg0, compiler),
@@ -187,6 +192,7 @@ fn compile_lines(
             }
 
             SimpleLine::Match { value, arms } => {
+                todo!(); // amend stack frame layout
                 let match_index = compiler.match_blocks.len();
                 let end_label = Label::match_end(match_index);
 
@@ -257,6 +263,7 @@ fn compile_lines(
                 else_branch,
                 line_number,
             } => {
+                todo!(); // amend stack frame layout
                 validate_vars_declared(&[condition], declared_vars)?;
 
                 let if_id = compiler.if_counter;
@@ -386,6 +393,7 @@ fn compile_lines(
                 return_data,
                 line_number,
             } => {
+                todo!(); // amend stack frame layout
                 let call_id = compiler.call_counter;
                 compiler.call_counter += 1;
                 let return_label = Label::return_from_call(call_id, *line_number);
@@ -435,6 +443,7 @@ fn compile_lines(
             }
 
             SimpleLine::Precompile { table, args, .. } => {
+                todo!(); // amend stack frame layout?
                 if *table == Table::poseidon24() {
                     assert_eq!(args.len(), 3);
                 } else {
@@ -477,6 +486,7 @@ fn compile_lines(
                 vectorized,
                 vectorized_len,
             } => {
+                todo!(); // amend stack frame layout
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
@@ -486,6 +496,7 @@ fn compile_lines(
                 });
             }
             SimpleLine::ConstMalloc { var, size, label } => {
+                todo!(); // amend stack frame layout
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
                 handle_const_malloc(declared_vars, &mut instructions, compiler, var, size, label);
             }
@@ -494,6 +505,7 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
+                todo!(); // amend stack frame layout
                 instructions.push(IntermediateInstruction::DecomposeBits {
                     res_offset: compiler.stack_size,
                     to_decompose: to_decompose
@@ -516,6 +528,7 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
+                todo!(); // amend stack frame layout
                 instructions.push(IntermediateInstruction::DecomposeCustom {
                     res_offset: compiler.stack_size,
                     to_decompose: to_decompose
@@ -534,6 +547,7 @@ fn compile_lines(
                 );
             }
             SimpleLine::CounterHint { var } => {
+                todo!(); // amend stack frame layout
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::CounterHint {
                     res_offset: compiler
@@ -576,6 +590,7 @@ fn handle_const_malloc(
     size: usize,
     label: &ConstMallocLabel,
 ) {
+    todo!(); // amend stack frame layout
     declared_vars.insert(var.clone());
     instructions.push(IntermediateInstruction::Computation {
         operation: Operation::Add,
@@ -673,6 +688,7 @@ fn compile_function_ret(
     });
 }
 
+// TODO: delete this?
 fn find_internal_vars(lines: &[SimpleLine]) -> BTreeSet<Var> {
     let mut internal_vars = BTreeSet::new();
     for line in lines {
diff --git a/crates/lean_compiler/src/grammar.pest b/crates/lean_compiler/src/grammar.pest
index d6fc7d1a..8de5a975 100644
--- a/crates/lean_compiler/src/grammar.pest
+++ b/crates/lean_compiler/src/grammar.pest
@@ -16,6 +16,7 @@ return_count = { "->" ~ number }
 
 // Statements
 statement = {
+    forward_declaration |
     single_assignment |
     array_assign |
     if_statement |
@@ -34,6 +35,8 @@ return_statement = { "return" ~ (tuple_expression)? ~ ";" }
 break_statement = { "break" ~ ";" }
 continue_statement = { "continue" ~ ";" }
 
+forward_declaration = { "var" ~ identifier ~ ";" }
+
 single_assignment = { identifier ~ "=" ~ expression ~ ";" }
 
 array_assign = { identifier ~ "[" ~ expression ~ "]" ~ "=" ~ expression ~ ";" }
diff --git a/crates/lean_compiler/src/lang.rs b/crates/lean_compiler/src/lang.rs
index ba1c001a..c5391b65 100644
--- a/crates/lean_compiler/src/lang.rs
+++ b/crates/lean_compiler/src/lang.rs
@@ -1,7 +1,7 @@
 use lean_vm::*;
 use multilinear_toolkit::prelude::*;
 use p3_util::log2_ceil_usize;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::fmt::{Display, Formatter};
 use utils::ToUsize;
 
@@ -307,6 +307,7 @@ pub enum Line {
         value: Expression,
         arms: Vec<(usize, Vec<Self>)>,
     },
+    ForwardDeclaration { var: Var },
     Assignment {
         var: Var,
         value: Expression,
@@ -379,6 +380,29 @@ pub enum Line {
         location: SourceLineNumber,
     },
 }
+
+/// A context specifying which variables are in scope.
+pub struct Context {
+    /// A list of lexical scopes, innermost scope last.
+    pub scopes: Vec<Scope>,
+}
+
+impl Context {
+    pub fn defines(&self, var: &Var) -> bool {
+        for scope in self.scopes.iter() {
+            if scope.vars.contains(var) {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+pub struct Scope {
+    /// A set of declared variables.
+    pub vars: BTreeSet<Var>,
+}
+
 impl Display for Expression {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -419,6 +443,9 @@ impl Line {
                     .join("\n");
                 format!("match {value} {{\n{arms_str}\n{spaces}}}")
             }
+            Self::ForwardDeclaration { var } => {
+                format!("var {var}")
+            }
             Self::Assignment { var, value } => {
                 format!("{var} = {value}")
             }
diff --git a/crates/lean_compiler/src/parser/parsers/statement.rs b/crates/lean_compiler/src/parser/parsers/statement.rs
index eb13e585..983acf93 100644
--- a/crates/lean_compiler/src/parser/parsers/statement.rs
+++ b/crates/lean_compiler/src/parser/parsers/statement.rs
@@ -19,6 +19,7 @@ impl Parse<Line> for StatementParser {
         let inner = next_inner_pair(&mut pair.into_inner(), "statement body")?;
 
         match inner.as_rule() {
+            Rule::forward_declaration => ForwardDeclarationParser::parse(inner, ctx),
             Rule::single_assignment => AssignmentParser::parse(inner, ctx),
             Rule::array_assign => ArrayAssignParser::parse(inner, ctx),
             Rule::if_statement => IfStatementParser::parse(inner, ctx),
@@ -35,6 +36,17 @@ impl Parse<Line> for StatementParser {
     }
 }
 
+/// Parser for forward declarations of variables.
+pub struct ForwardDeclarationParser;
+
+impl Parse<Line> for ForwardDeclarationParser {
+    fn parse(pair: ParsePair<'_>, ctx: &mut ParseContext) -> ParseResult<Line> {
+        let mut inner = pair.into_inner();
+        let var = next_inner_pair(&mut inner, "variable name")?.as_str().to_string();
+        Ok(Line::ForwardDeclaration { var })
+    }
+}
+
 /// Parser for variable assignments.
 pub struct AssignmentParser;
 
diff --git a/crates/rec_aggregation/recursion_program.lean_lang b/crates/rec_aggregation/recursion_program.lean_lang
index 3d7e161b..3c5b62a6 100644
--- a/crates/rec_aggregation/recursion_program.lean_lang
+++ b/crates/rec_aggregation/recursion_program.lean_lang
@@ -292,15 +292,16 @@ fn sample_stir_indexes_and_fold(fs_state, num_queries, merkle_leaves_in_basefiel
     fs_states_b = malloc(num_queries + 1);
     fs_states_b[0] = fs_state_9;
     
+    var n_chunks_per_answer;
     // the number of chunk of 8 field elements per merkle leaf opened
     if merkle_leaves_in_basefield == 1 {
-        n_chuncks_per_answer = two_pow_folding_factor / 8; // "/ 8" because initial merkle leaves are in the basefield
+        n_chunks_per_answer = two_pow_folding_factor / 8; // "/ 8" because initial merkle leaves are in the basefield
     } else {
-        n_chuncks_per_answer = two_pow_folding_factor * DIM / 8;
+        n_chunks_per_answer = two_pow_folding_factor * DIM / 8;
     }
 
     for i in 0..num_queries {
-        new_fs_state, answer = fs_hint(fs_states_b[i], n_chuncks_per_answer); 
+        new_fs_state, answer = fs_hint(fs_states_b[i], n_chunks_per_answer); 
         fs_states_b[i + 1] = new_fs_state;
         answers[i] = answer;
     }
@@ -309,14 +310,14 @@ fn sample_stir_indexes_and_fold(fs_state, num_queries, merkle_leaves_in_basefiel
     leaf_hashes = malloc(num_queries); // a vector of vectorized pointers, each pointing to 1 chunk of 8 field elements
     for i in 0..num_queries {
         answer = answers[i];
-        internal_states = malloc(1 + (n_chuncks_per_answer / 2)); // "/ 2" because with poseidon24 we hash 2 chuncks of 8 field elements at each permutation
+        internal_states = malloc(1 + (n_chunks_per_answer / 2)); // "/ 2" because with poseidon24 we hash 2 chuncks of 8 field elements at each permutation
         internal_states[0] = pointer_to_zero_vector; // initial state
-        for j in 0..n_chuncks_per_answer / 2 {
+        for j in 0..n_chunks_per_answer / 2 {
             h24 = malloc_vec(1);
             poseidon24(answer + (2*j), internal_states[j], h24);
             internal_states[j + 1] = h24;
         }
-        leaf_hashes[i] = internal_states[n_chuncks_per_answer / 2];
+        leaf_hashes[i] = internal_states[n_chunks_per_answer / 2];
     }
 
     folded_domain_size = domain_size - folding_factor;

From f3942d28d625a16c30dd0c13d37f8ab5c86e66b7 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Sat, 29 Nov 2025 17:21:13 +0000
Subject: [PATCH 02/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs   | 36 +++-----
 .../src/b_compile_intermediate.rs             | 90 ++++++++++++-------
 crates/lean_compiler/src/lang.rs              |  1 +
 crates/lean_compiler/src/lib.rs               |  4 +-
 4 files changed, 70 insertions(+), 61 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index b23b01b4..70413fe0 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -371,7 +371,6 @@ struct ArrayManager {
 pub struct ConstMalloc {
     counter: usize,
     map: BTreeMap<Var, ConstMallocLabel>,
-    forbidden_vars: BTreeSet<Var>, // vars shared between branches of an if/else
 }
 
 impl ArrayManager {
@@ -397,8 +396,8 @@ fn simplify_lines(
     let mut res = Vec::new();
     for line in lines {
         match line {
-            Line::ForwardDeclaration { var: _ } => {
-                todo!();
+            Line::ForwardDeclaration { var } => {
+                res.push(SimpleLine::ForwardDeclaration { var: var.clone() });
             },
             Line::Match { value, arms } => {
                 let simple_value = simplify_expr(value, &mut res, counters, array_manager, const_malloc);
@@ -555,17 +554,6 @@ fn simplify_lines(
                     }
                 };
 
-                let forbidden_vars_before = const_malloc.forbidden_vars.clone();
-
-                let then_internal_vars = find_variable_usage(then_branch).0;
-                let else_internal_vars = find_variable_usage(else_branch).0;
-                let new_forbidden_vars = then_internal_vars
-                    .intersection(&else_internal_vars)
-                    .cloned()
-                    .collect::<BTreeSet<_>>();
-
-                const_malloc.forbidden_vars.extend(new_forbidden_vars);
-
                 let mut array_manager_then = array_manager.clone();
                 let then_branch_simplified = simplify_lines(
                     then_branch,
@@ -587,8 +575,6 @@ fn simplify_lines(
                     const_malloc,
                 );
 
-                const_malloc.forbidden_vars = forbidden_vars_before;
-
                 *array_manager = array_manager_else.clone();
                 // keep the intersection both branches
                 array_manager.valid = array_manager
@@ -650,6 +636,8 @@ fn simplify_lines(
                     counter: const_malloc.counter,
                     ..ConstMalloc::default()
                 };
+                // TODO: what is array manager, and does it need to be updated
+                // to make block-level scoping work?
                 let valid_aux_vars_in_array_manager_before = array_manager.valid.clone();
                 array_manager.valid.clear();
                 let simplified_body = simplify_lines(
@@ -781,12 +769,8 @@ fn simplify_lines(
                 let simplified_size = simplify_expr(size, &mut res, counters, array_manager, const_malloc);
                 let simplified_vectorized_len =
                     simplify_expr(vectorized_len, &mut res, counters, array_manager, const_malloc);
-                if simplified_size.is_constant() && !*vectorized && const_malloc.forbidden_vars.contains(var) {
-                    println!("TODO: Optimization missed: Requires to align const malloc in if/else branches");
-                }
                 match simplified_size {
-                    SimpleExpr::Constant(const_size) if !*vectorized && !const_malloc.forbidden_vars.contains(var) => {
-                        // TODO do this optimization even if we are in an if/else branch
+                    SimpleExpr::Constant(const_size) if !*vectorized => {
                         let label = const_malloc.counter;
                         const_malloc.counter += 1;
                         const_malloc.map.insert(var.clone(), label);
@@ -807,7 +791,6 @@ fn simplify_lines(
                 }
             }
             Line::DecomposeBits { var, to_decompose } => {
-                assert!(!const_malloc.forbidden_vars.contains(var), "TODO");
                 let simplified_to_decompose = to_decompose
                     .iter()
                     .map(|expr| simplify_expr(expr, &mut res, counters, array_manager, const_malloc))
@@ -822,7 +805,6 @@ fn simplify_lines(
                 });
             }
             Line::DecomposeCustom { var, to_decompose } => {
-                assert!(!const_malloc.forbidden_vars.contains(var), "TODO");
                 let simplified_to_decompose = to_decompose
                     .iter()
                     .map(|expr| simplify_expr(expr, &mut res, counters, array_manager, const_malloc))
@@ -949,9 +931,8 @@ pub fn find_variable_usage(lines: &[Line]) -> (BTreeSet<Var>, BTreeSet<Var>) {
 
     for line in lines {
         match line {
-            Line::ForwardDeclaration { var: _ } => {
-                todo!();
-                // internal_vars.push(var.clone()); // if declaring is using; otherwise do nothing
+            Line::ForwardDeclaration { var } => {
+                internal_vars.insert(var.clone());
             },
             Line::Match { value, arms } => {
                 on_new_expr(value, &internal_vars, &mut external_vars);
@@ -1997,6 +1978,9 @@ impl SimpleLine {
     fn to_string_with_indent(&self, indent: usize) -> String {
         let spaces = "    ".repeat(indent);
         let line_str = match self {
+            Self::ForwardDeclaration { var } => {
+                format!("var {var}")
+            }
             Self::Match { value, arms } => {
                 let arms_str = arms
                     .iter()
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index e2ffb82e..f8bda647 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -19,6 +19,7 @@ struct Compiler {
     stack_size: usize,
 }
 
+#[derive(Default)]
 struct StackFrameLayout {
     // Innermost lexical scope last
     scopes: Vec<ScopeLayout>,
@@ -36,7 +37,7 @@ impl Compiler {
             VarOrConstMallocAccess::Var(var) => {
                 for scope in self.stack_frame_layout.scopes.iter().rev() {
                     if let Some(offset) = scope.var_positions.get(var) {
-                        return offset.into();
+                        return (*offset).into();
                     }
                 }
                 panic!("Variable {var} not in scope");
@@ -45,9 +46,9 @@ impl Compiler {
                 for scope in self.stack_frame_layout.scopes.iter().rev() {
                     if let Some(base) = scope.const_mallocs.get(malloc_label) {
                         return ConstExpression::Binary {
-                            left: Box::new(base.into()),
+                            left: Box::new((*base).into()),
                             operation: HighLevelOperation::Add,
-                            right: Box::new(offset.clone()),
+                            right: Box::new((*offset).clone()),
                         };
                     }
                 }
@@ -82,7 +83,10 @@ impl IntermediateValue {
             },
             SimpleExpr::Constant(c) => Self::Constant(c.clone()),
             SimpleExpr::ConstMallocAccess { malloc_label, offset } => Self::MemoryAfterFp {
-                offset: compiler.get_offset(SimpleExpr::ConstMallocAccess { malloc_label, offset }),
+                offset: compiler.get_offset(&VarOrConstMallocAccess::ConstMallocAccess {
+                    malloc_label: *malloc_label,
+                    offset: offset.clone()
+                }),
             },
         }
     }
@@ -115,15 +119,14 @@ fn compile_function(
 ) -> Result<Vec<IntermediateInstruction>, String> {
     // memory layout: pc, fp, args, return_vars, internal_vars
     let mut stack_pos = 2; // Reserve space for pc and fp
-    let mut var_positions = BTreeMap::new();
-    let mut function_scope = Scope::default();
+    let mut function_scope_layout = ScopeLayout::default();
     compiler.stack_frame_layout = StackFrameLayout {
-        scopes: vec![function_scope],
+        scopes: vec![function_scope_layout],
     };
-    let function_scope = &mut compiler.stack_frame_layout.scopes[0];
+    let function_scope_layout = &mut compiler.stack_frame_layout.scopes[0];
 
     for (i, var) in function.arguments.iter().enumerate() {
-        function_scope.var_positions.insert(var.clone(), stack_pos + i);
+        function_scope_layout.var_positions.insert(var.clone(), stack_pos + i);
     }
     stack_pos += function.arguments.len();
 
@@ -150,14 +153,14 @@ fn compile_lines(
     final_jump: Option<Label>,
     declared_vars: &mut BTreeSet<Var>,
 ) -> Result<Vec<IntermediateInstruction>, String> {
-    // TODO: amend stack frame layout with internal variables.
-
     let mut instructions = Vec::new();
 
     for (i, line) in lines.iter().enumerate() {
         match line {
-            SimpleLine::ForwardDeclaration => {
-                todo!(); // amend stack frame layout
+            SimpleLine::ForwardDeclaration { var } => {
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
+                compiler.stack_size += 1;
             }
 
             SimpleLine::Assignment {
@@ -166,18 +169,23 @@ fn compile_lines(
                 arg0,
                 arg1,
             } => {
-                todo!(); // amend stack frame layout
-                instructions.push(IntermediateInstruction::computation(
-                    *operation,
-                    IntermediateValue::from_simple_expr(arg0, compiler),
-                    IntermediateValue::from_simple_expr(arg1, compiler),
-                    IntermediateValue::from_var_or_const_malloc_access(var, compiler),
-                ));
-
                 mark_vars_as_declared(&[arg0, arg1], declared_vars);
+                let arg0 = IntermediateValue::from_simple_expr(arg0, compiler);
+                let arg1 = IntermediateValue::from_simple_expr(arg1, compiler);
+
                 if let VarOrConstMallocAccess::Var(var) = var {
                     declared_vars.insert(var.clone());
+                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
+                    compiler.stack_size += 1;
                 }
+
+                instructions.push(IntermediateInstruction::computation(
+                    *operation,
+                    arg0,
+                    arg1,
+                    IntermediateValue::from_var_or_const_malloc_access(var, compiler),
+                ));
             }
 
             SimpleLine::TestZero { operation, arg0, arg1 } => {
@@ -192,7 +200,9 @@ fn compile_lines(
             }
 
             SimpleLine::Match { value, arms } => {
-                todo!(); // amend stack frame layout
+                let saved_stack_size = compiler.stack_size;
+                compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
+
                 let match_index = compiler.match_blocks.len();
                 let end_label = Label::match_end(match_index);
 
@@ -254,6 +264,9 @@ fn compile_lines(
                 let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump, declared_vars)?;
                 compiler.bytecode.insert(end_label, remaining);
 
+                compiler.stack_frame_layout.scopes.pop();
+                compiler.stack_size = saved_stack_size;
+
                 return Ok(instructions);
             }
 
@@ -263,7 +276,9 @@ fn compile_lines(
                 else_branch,
                 line_number,
             } => {
-                todo!(); // amend stack frame layout
+                let saved_stack_size = compiler.stack_size;
+                compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
+
                 validate_vars_declared(&[condition], declared_vars)?;
 
                 let if_id = compiler.if_counter;
@@ -368,6 +383,9 @@ fn compile_lines(
                 let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump, declared_vars)?;
                 compiler.bytecode.insert(end_label, remaining);
 
+                compiler.stack_frame_layout.scopes.pop();
+                compiler.stack_size = saved_stack_size;
+
                 return Ok(instructions);
             }
 
@@ -393,7 +411,6 @@ fn compile_lines(
                 return_data,
                 line_number,
             } => {
-                todo!(); // amend stack frame layout
                 let call_id = compiler.call_counter;
                 compiler.call_counter += 1;
                 let return_label = Label::return_from_call(call_id, *line_number);
@@ -411,6 +428,11 @@ fn compile_lines(
 
                 validate_vars_declared(args, declared_vars)?;
                 declared_vars.extend(return_data.iter().cloned());
+                for var in return_data.iter() {
+                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
+                    compiler.stack_size += 1;
+                }
 
                 let after_call = {
                     let mut instructions = Vec::new();
@@ -443,7 +465,6 @@ fn compile_lines(
             }
 
             SimpleLine::Precompile { table, args, .. } => {
-                todo!(); // amend stack frame layout?
                 if *table == Table::poseidon24() {
                     assert_eq!(args.len(), 3);
                 } else {
@@ -486,7 +507,9 @@ fn compile_lines(
                 vectorized,
                 vectorized_len,
             } => {
-                todo!(); // amend stack frame layout
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
+                compiler.stack_size += 1;
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
@@ -496,7 +519,6 @@ fn compile_lines(
                 });
             }
             SimpleLine::ConstMalloc { var, size, label } => {
-                todo!(); // amend stack frame layout
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
                 handle_const_malloc(declared_vars, &mut instructions, compiler, var, size, label);
             }
@@ -505,7 +527,6 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
-                todo!(); // amend stack frame layout
                 instructions.push(IntermediateInstruction::DecomposeBits {
                     res_offset: compiler.stack_size,
                     to_decompose: to_decompose
@@ -528,7 +549,6 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
-                todo!(); // amend stack frame layout
                 instructions.push(IntermediateInstruction::DecomposeCustom {
                     res_offset: compiler.stack_size,
                     to_decompose: to_decompose
@@ -547,7 +567,9 @@ fn compile_lines(
                 );
             }
             SimpleLine::CounterHint { var } => {
-                todo!(); // amend stack frame layout
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
+                compiler.stack_size += 1;
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::CounterHint {
                     res_offset: compiler
@@ -590,7 +612,6 @@ fn handle_const_malloc(
     size: usize,
     label: &ConstMallocLabel,
 ) {
-    todo!(); // amend stack frame layout
     declared_vars.insert(var.clone());
     instructions.push(IntermediateInstruction::Computation {
         operation: Operation::Add,
@@ -600,7 +621,8 @@ fn handle_const_malloc(
             offset: compiler.get_offset(&var.clone().into()),
         },
     });
-    compiler.const_mallocs.insert(*label, compiler.stack_size);
+    let current_scope = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+    current_scope.const_mallocs.insert(*label, compiler.stack_size);
     compiler.stack_size += size;
 }
 
@@ -688,11 +710,13 @@ fn compile_function_ret(
     });
 }
 
-// TODO: delete this?
 fn find_internal_vars(lines: &[SimpleLine]) -> BTreeSet<Var> {
     let mut internal_vars = BTreeSet::new();
     for line in lines {
         match line {
+            SimpleLine::ForwardDeclaration { var } => {
+                internal_vars.insert(var.clone());
+            }
             SimpleLine::Match { arms, .. } => {
                 for arm in arms {
                     internal_vars.extend(find_internal_vars(arm));
diff --git a/crates/lean_compiler/src/lang.rs b/crates/lean_compiler/src/lang.rs
index c5391b65..345b8628 100644
--- a/crates/lean_compiler/src/lang.rs
+++ b/crates/lean_compiler/src/lang.rs
@@ -398,6 +398,7 @@ impl Context {
     }
 }
 
+#[derive(Default)]
 pub struct Scope {
     /// A set of declared variables.
     pub vars: BTreeSet<Var>,
diff --git a/crates/lean_compiler/src/lib.rs b/crates/lean_compiler/src/lib.rs
index d23ffe5b..257a00a1 100644
--- a/crates/lean_compiler/src/lib.rs
+++ b/crates/lean_compiler/src/lib.rs
@@ -16,9 +16,9 @@ pub fn compile_program(program: String) -> Bytecode {
     let (parsed_program, function_locations) = parse_program(&program).unwrap();
     // println!("Parsed program: {}", parsed_program.to_string());
     let simple_program = simplify_program(parsed_program);
-    // println!("Simplified program: {}", simple_program.to_string());
+    println!("Simplified program: {}", simple_program.to_string());
     let intermediate_bytecode = compile_to_intermediate_bytecode(simple_program).unwrap();
-    // println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
+    println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
 
     // println!("Function Locations: \n");
     // for (loc, name) in function_locations.iter() {

From 369faca9b2724676001ad80265d0d6abc717e340 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Sun, 30 Nov 2025 03:48:39 +0000
Subject: [PATCH 03/20] issue/94: include last pc in stack trace

---
 crates/lean_vm/src/diagnostics/stack_trace.rs |  7 ++++++-
 crates/lean_vm/src/execution/runner.rs        | 15 ++++++++-------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/crates/lean_vm/src/diagnostics/stack_trace.rs b/crates/lean_vm/src/diagnostics/stack_trace.rs
index e9100de7..c3b4487e 100644
--- a/crates/lean_vm/src/diagnostics/stack_trace.rs
+++ b/crates/lean_vm/src/diagnostics/stack_trace.rs
@@ -10,6 +10,7 @@ pub(crate) fn pretty_stack_trace(
     source_code: &str,
     instructions: &[SourceLineNumber], // SourceLineNumber = usize
     function_locations: &BTreeMap<usize, String>,
+    last_pc: usize,
 ) -> String {
     let source_lines: Vec<&str> = source_code.lines().collect();
     let mut result = String::new();
@@ -97,7 +98,11 @@ pub(crate) fn pretty_stack_trace(
     if !call_stack.is_empty() {
         result.push_str("\nCall stack:\n");
         for (i, (line, func)) in call_stack.iter().enumerate() {
-            result.push_str(&format!("  {}. {} (line {})\n", i + 1, func, line));
+            if i + 1 == call_stack.len() {
+                result.push_str(&format!("  {}. {} (line {}, pc {})\n", i + 1, func, line, last_pc));
+            } else {
+                result.push_str(&format!("  {}. {} (line {})\n", i + 1, func, line));
+            }
         }
     }
 
diff --git a/crates/lean_vm/src/execution/runner.rs b/crates/lean_vm/src/execution/runner.rs
index 2abb0bbe..381a9310 100644
--- a/crates/lean_vm/src/execution/runner.rs
+++ b/crates/lean_vm/src/execution/runner.rs
@@ -70,7 +70,7 @@ pub fn execute_bytecode(
         profiling,
         (poseidons_16_precomputed, poseidons_24_precomputed),
     )
-    .unwrap_or_else(|err| {
+    .unwrap_or_else(|(last_pc, err)| {
         let lines_history = &instruction_history.lines;
         let latest_instructions = &lines_history[lines_history.len().saturating_sub(STACK_TRACE_INSTRUCTIONS)..];
         println!(
@@ -78,7 +78,8 @@ pub fn execute_bytecode(
             crate::diagnostics::pretty_stack_trace(
                 &bytecode.program,
                 latest_instructions,
-                &bytecode.function_locations
+                &bytecode.function_locations,
+                last_pc
             )
         );
         if !std_out.is_empty() {
@@ -146,7 +147,7 @@ fn execute_bytecode_helper(
     no_vec_runtime_memory: usize,
     profiling: bool,
     (poseidons_16_precomputed, poseidons_24_precomputed): (&Poseidon16History, &Poseidon24History),
-) -> Result<ExecutionResult, RunnerError> {
+) -> Result<ExecutionResult, (CodeAddress, RunnerError)> {
     // set public memory
     let mut memory = Memory::new(build_public_memory(public_input));
 
@@ -154,7 +155,7 @@ fn execute_bytecode_helper(
     let mut fp = public_memory_size;
 
     for (i, value) in private_input.iter().enumerate() {
-        memory.set(fp + i, *value)?;
+        memory.set(fp + i, *value).expect("to set private input in memory");
     }
 
     let mut mem_profile = MemoryProfile {
@@ -199,7 +200,7 @@ fn execute_bytecode_helper(
 
     while pc != ENDING_PC {
         if pc >= bytecode.instructions.len() {
-            return Err(RunnerError::PCOutOfBounds);
+            return Err((pc, RunnerError::PCOutOfBounds));
         }
 
         pcs.push(pc);
@@ -225,7 +226,7 @@ fn execute_bytecode_helper(
                 profiling,
                 memory_profile: &mut mem_profile,
             };
-            hint.execute_hint(&mut hint_ctx)?;
+            hint.execute_hint(&mut hint_ctx).map_err(|e| (pc, e))?;
         }
 
         let instruction = &bytecode.instructions[pc];
@@ -244,7 +245,7 @@ fn execute_bytecode_helper(
             n_poseidon16_precomputed_used: &mut n_poseidon16_precomputed_used,
             n_poseidon24_precomputed_used: &mut n_poseidon24_precomputed_used,
         };
-        instruction.execute_instruction(&mut instruction_ctx)?;
+        instruction.execute_instruction(&mut instruction_ctx).map_err(|e| (pc, e))?;
     }
 
     assert_eq!(

From cccf7506c56271c5b58da727712e000d3a679568 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Sun, 30 Nov 2025 03:57:58 +0000
Subject: [PATCH 04/20] improve specificity of MemoryAlreadySet error message

---
 crates/lean_compiler/src/lib.rs         | 5 +++--
 crates/lean_vm/src/diagnostics/error.rs | 8 ++++++--
 crates/lean_vm/src/execution/memory.rs  | 6 +++++-
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/crates/lean_compiler/src/lib.rs b/crates/lean_compiler/src/lib.rs
index 257a00a1..3b8cbdf2 100644
--- a/crates/lean_compiler/src/lib.rs
+++ b/crates/lean_compiler/src/lib.rs
@@ -24,8 +24,9 @@ pub fn compile_program(program: String) -> Bytecode {
     // for (loc, name) in function_locations.iter() {
     //     println!("{name}: {loc}");
     // }
-    // println!("\n\nCompiled Program:\n\n{compiled}");
-    compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap()
+    let compiled = compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap();
+    println!("\n\nCompiled Program:\n\n{compiled}");
+    compiled
 }
 
 pub fn compile_and_run(
diff --git a/crates/lean_vm/src/diagnostics/error.rs b/crates/lean_vm/src/diagnostics/error.rs
index 80216c68..1659d3c9 100644
--- a/crates/lean_vm/src/diagnostics/error.rs
+++ b/crates/lean_vm/src/diagnostics/error.rs
@@ -9,8 +9,12 @@ pub enum RunnerError {
     #[error("Out of memory")]
     OutOfMemory,
 
-    #[error("Memory already set")]
-    MemoryAlreadySet,
+    #[error("Memory already set: m[{address}] = {prev_value} != {new_value}")]
+    MemoryAlreadySet {
+        address: usize,
+        prev_value: F,
+        new_value: F,
+    },
 
     #[error("Not a pointer")]
     NotAPointer,
diff --git a/crates/lean_vm/src/execution/memory.rs b/crates/lean_vm/src/execution/memory.rs
index aa19397d..a162fb46 100644
--- a/crates/lean_vm/src/execution/memory.rs
+++ b/crates/lean_vm/src/execution/memory.rs
@@ -41,7 +41,11 @@ impl Memory {
         }
         if let Some(existing) = &mut self.0[index] {
             if *existing != value {
-                return Err(RunnerError::MemoryAlreadySet);
+                return Err(RunnerError::MemoryAlreadySet {
+                    address: index,
+                    prev_value: *existing,
+                    new_value: value,
+                });
             }
         } else {
             self.0[index] = Some(value);

From 380fcb73bf2cbd751e31ecc9b921603cc48bbc7a Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Sun, 30 Nov 2025 22:22:35 +0000
Subject: [PATCH 05/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs   |   2 +-
 .../src/b_compile_intermediate.rs             | 154 ++++++++++--------
 2 files changed, 88 insertions(+), 68 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index 70413fe0..bcd068db 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -2042,7 +2042,7 @@ impl SimpleLine {
                 format!("{result} = counter_hint()")
             }
             Self::RawAccess { res, index, shift } => {
-                format!("memory[{index} + {shift}] = {res}")
+                format!("{res} = memory[{index} + {shift}]")
             }
             Self::TestZero { operation, arg0, arg1 } => {
                 format!("0 = {arg0} {operation} {arg1}")
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index f8bda647..861a64ed 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -17,6 +17,7 @@ struct Compiler {
     stack_frame_layout: StackFrameLayout,
     args_count: usize,
     stack_size: usize,
+    stack_pos: usize,
 }
 
 #[derive(Default)]
@@ -133,6 +134,7 @@ fn compile_function(
     stack_pos += function.n_returned_vars;
 
     compiler.func_name = function.name.clone();
+    compiler.stack_pos = stack_pos;
     compiler.stack_size = stack_pos;
     compiler.args_count = function.arguments.len();
 
@@ -159,8 +161,8 @@ fn compile_lines(
         match line {
             SimpleLine::ForwardDeclaration { var } => {
                 let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
-                compiler.stack_size += 1;
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += 1;
             }
 
             SimpleLine::Assignment {
@@ -176,8 +178,8 @@ fn compile_lines(
                 if let VarOrConstMallocAccess::Var(var) = var {
                     declared_vars.insert(var.clone());
                     let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
-                    compiler.stack_size += 1;
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
                 }
 
                 instructions.push(IntermediateInstruction::computation(
@@ -196,11 +198,12 @@ fn compile_lines(
                     IntermediateValue::Constant(0.into()),
                 ));
 
+                // TODO: why is mark_vars_as_declared here?
                 mark_vars_as_declared(&[arg0, arg1], declared_vars);
             }
 
             SimpleLine::Match { value, arms } => {
-                let saved_stack_size = compiler.stack_size;
+                let saved_stack_pos = compiler.stack_pos;
                 compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
 
                 let match_index = compiler.match_blocks.len();
@@ -209,11 +212,9 @@ fn compile_lines(
                 let value_simplified = IntermediateValue::from_simple_expr(value, compiler);
 
                 let mut compiled_arms = vec![];
-                let original_stack_size = compiler.stack_size;
-                let mut new_stack_size = original_stack_size;
                 for (i, arm) in arms.iter().enumerate() {
                     let mut arm_declared_vars = declared_vars.clone();
-                    compiler.stack_size = original_stack_size;
+                    compiler.stack_pos = saved_stack_pos;
                     let arm_instructions = compile_lines(
                         function_name,
                         arm,
@@ -222,23 +223,21 @@ fn compile_lines(
                         &mut arm_declared_vars,
                     )?;
                     compiled_arms.push(arm_instructions);
-                    new_stack_size = compiler.stack_size.max(new_stack_size);
                     *declared_vars = if i == 0 {
                         arm_declared_vars
                     } else {
                         declared_vars.intersection(&arm_declared_vars).cloned().collect()
                     };
                 }
-                compiler.stack_size = new_stack_size;
                 compiler.match_blocks.push(MatchBlock {
                     function_name: function_name.clone(),
                     match_cases: compiled_arms,
                 });
 
                 let value_scaled_offset = IntermediateValue::MemoryAfterFp {
-                    offset: compiler.stack_size.into(),
+                    offset: compiler.stack_pos.into(),
                 };
-                compiler.stack_size += 1;
+                compiler.stack_pos += 1;
                 instructions.push(IntermediateInstruction::Computation {
                     operation: Operation::Mul,
                     arg_a: value_simplified,
@@ -247,9 +246,9 @@ fn compile_lines(
                 });
 
                 let jump_dest_offset = IntermediateValue::MemoryAfterFp {
-                    offset: compiler.stack_size.into(),
+                    offset: compiler.stack_pos.into(),
                 };
-                compiler.stack_size += 1;
+                compiler.stack_pos += 1;
                 instructions.push(IntermediateInstruction::Computation {
                     operation: Operation::Add,
                     arg_a: value_scaled_offset,
@@ -265,7 +264,9 @@ fn compile_lines(
                 compiler.bytecode.insert(end_label, remaining);
 
                 compiler.stack_frame_layout.scopes.pop();
-                compiler.stack_size = saved_stack_size;
+                compiler.stack_pos = saved_stack_pos;
+                // It is not necessary to update compiler.stack_size here because the preceding call to
+                // compile lines should have done so.
 
                 return Ok(instructions);
             }
@@ -276,7 +277,6 @@ fn compile_lines(
                 else_branch,
                 line_number,
             } => {
-                let saved_stack_size = compiler.stack_size;
                 compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
 
                 validate_vars_declared(&[condition], declared_vars)?;
@@ -294,16 +294,16 @@ fn compile_lines(
                 let condition_simplified = IntermediateValue::from_simple_expr(condition, compiler);
 
                 // 1/c (or 0 if c is zero)
-                let condition_inverse_offset = compiler.stack_size;
-                compiler.stack_size += 1;
+                let condition_inverse_offset = compiler.stack_pos;
+                compiler.stack_pos += 1;
                 instructions.push(IntermediateInstruction::Inverse {
                     arg: condition_simplified.clone(),
                     res_offset: condition_inverse_offset,
                 });
 
                 // c x 1/c
-                let product_offset = compiler.stack_size;
-                compiler.stack_size += 1;
+                let product_offset = compiler.stack_pos;
+                compiler.stack_pos += 1;
                 instructions.push(IntermediateInstruction::Computation {
                     operation: Operation::Mul,
                     arg_a: condition_simplified.clone(),
@@ -314,10 +314,12 @@ fn compile_lines(
                         offset: product_offset.into(),
                     },
                 });
+                // It is not necessary to update compiler.stack_size here because the preceding call to
+                // compile lines should have done so.
 
                 // 1 - (c x 1/c)
-                let one_minus_product_offset = compiler.stack_size;
-                compiler.stack_size += 1;
+                let one_minus_product_offset = compiler.stack_pos;
+                compiler.stack_pos += 1;
                 instructions.push(IntermediateInstruction::Computation {
                     operation: Operation::Add,
                     arg_a: IntermediateValue::MemoryAfterFp {
@@ -351,7 +353,7 @@ fn compile_lines(
                     updated_fp: None,
                 });
 
-                let original_stack = compiler.stack_size;
+                let saved_stack_pos = compiler.stack_pos;
 
                 let mut then_declared_vars = declared_vars.clone();
                 let then_instructions = compile_lines(
@@ -361,9 +363,9 @@ fn compile_lines(
                     Some(end_label.clone()),
                     &mut then_declared_vars,
                 )?;
-                let then_stack = compiler.stack_size;
 
-                compiler.stack_size = original_stack;
+                let then_stack_pos = compiler.stack_pos;
+                compiler.stack_pos = saved_stack_pos;
                 let mut else_declared_vars = declared_vars.clone();
                 let else_instructions = compile_lines(
                     function_name,
@@ -372,27 +374,29 @@ fn compile_lines(
                     Some(end_label.clone()),
                     &mut else_declared_vars,
                 )?;
-                let else_stack = compiler.stack_size;
-
-                compiler.stack_size = then_stack.max(else_stack);
-                *declared_vars = then_declared_vars.intersection(&else_declared_vars).cloned().collect();
 
                 compiler.bytecode.insert(if_label, then_instructions);
                 compiler.bytecode.insert(else_label, else_instructions);
 
+                compiler.stack_frame_layout.scopes.pop();
+                compiler.stack_pos = compiler.stack_pos.max(then_stack_pos);
+
                 let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump, declared_vars)?;
                 compiler.bytecode.insert(end_label, remaining);
-
-                compiler.stack_frame_layout.scopes.pop();
-                compiler.stack_size = saved_stack_size;
+                // It is not necessary to update compiler.stack_size here because the preceding call to
+                // compile_lines should have done so.
 
                 return Ok(instructions);
             }
 
             SimpleLine::RawAccess { res, index, shift } => {
+                // TODO: why is validate_vars_declared here?
                 validate_vars_declared(&[index], declared_vars)?;
                 if let SimpleExpr::Var(var) = res {
                     declared_vars.insert(var.clone());
+                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
                 }
                 let shift_0 = match index {
                     SimpleExpr::Constant(c) => c.clone(),
@@ -415,8 +419,8 @@ fn compile_lines(
                 compiler.call_counter += 1;
                 let return_label = Label::return_from_call(call_id, *line_number);
 
-                let new_fp_pos = compiler.stack_size;
-                compiler.stack_size += 1;
+                let new_fp_pos = compiler.stack_pos;
+                compiler.stack_pos += 1;
 
                 instructions.extend(setup_function_call(
                     callee_function_name,
@@ -426,12 +430,13 @@ fn compile_lines(
                     compiler,
                 )?);
 
+                // TODO: why is validate_vars_declared here?
                 validate_vars_declared(args, declared_vars)?;
                 declared_vars.extend(return_data.iter().cloned());
                 for var in return_data.iter() {
                     let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
-                    compiler.stack_size += 1;
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
                 }
 
                 let after_call = {
@@ -460,6 +465,8 @@ fn compile_lines(
                 };
 
                 compiler.bytecode.insert(return_label, after_call);
+                // It is not necessary to update compiler.stack_size here because the preceding call to
+                // compile_lines should have done so.
 
                 return Ok(instructions);
             }
@@ -483,9 +490,9 @@ fn compile_lines(
                 if compiler.func_name == "main" {
                     // pc -> ending_pc, fp -> 0
                     let zero_value_offset = IntermediateValue::MemoryAfterFp {
-                        offset: compiler.stack_size.into(),
+                        offset: compiler.stack_pos.into(),
                     };
-                    compiler.stack_size += 1;
+                    compiler.stack_pos += 1;
                     instructions.push(IntermediateInstruction::Computation {
                         operation: Operation::Add,
                         arg_a: IntermediateValue::Constant(0.into()),
@@ -508,8 +515,8 @@ fn compile_lines(
                 vectorized_len,
             } => {
                 let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
-                compiler.stack_size += 1;
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += 1;
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
@@ -520,6 +527,11 @@ fn compile_lines(
             }
             SimpleLine::ConstMalloc { var, size, label } => {
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
+                declared_vars.insert(var.clone());
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                current_scope_layout.const_mallocs.insert(*label, compiler.stack_pos + 1);
+                compiler.stack_pos += 1 + size;
                 handle_const_malloc(declared_vars, &mut instructions, compiler, var, size, label);
             }
             SimpleLine::DecomposeBits {
@@ -528,21 +540,26 @@ fn compile_lines(
                 label,
             } => {
                 instructions.push(IntermediateInstruction::DecomposeBits {
-                    res_offset: compiler.stack_size,
+                    res_offset: compiler.stack_pos,
                     to_decompose: to_decompose
                         .iter()
                         .map(|expr| IntermediateValue::from_simple_expr(expr, compiler))
                         .collect(),
                 });
-
-                handle_const_malloc(
-                    declared_vars,
-                    &mut instructions,
-                    compiler,
-                    var,
-                    F::bits() * to_decompose.len(),
-                    label,
-                );
+                declared_vars.insert(var.clone());
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += F::bits() * to_decompose.len();
+
+                // TODO: is handle_const_malloc needed?
+                // handle_const_malloc(
+                //     declared_vars,
+                //     &mut instructions,
+                //     compiler,
+                //     var,
+                //     F::bits() * to_decompose.len(),
+                //     label,
+                // );
             }
             SimpleLine::DecomposeCustom {
                 var,
@@ -550,26 +567,31 @@ fn compile_lines(
                 label,
             } => {
                 instructions.push(IntermediateInstruction::DecomposeCustom {
-                    res_offset: compiler.stack_size,
+                    res_offset: compiler.stack_pos,
                     to_decompose: to_decompose
                         .iter()
                         .map(|expr| IntermediateValue::from_simple_expr(expr, compiler))
                         .collect(),
                 });
-
-                handle_const_malloc(
-                    declared_vars,
-                    &mut instructions,
-                    compiler,
-                    var,
-                    F::bits() * to_decompose.len(),
-                    label,
-                );
+                declared_vars.insert(var.clone());
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += F::bits() * to_decompose.len();
+
+                // TODO: is handle_const_malloc needed?
+                // handle_const_malloc(
+                //     declared_vars,
+                //     &mut instructions,
+                //     compiler,
+                //     var,
+                //     F::bits() * to_decompose.len(),
+                //     label,
+                // );
             }
             SimpleLine::CounterHint { var } => {
                 let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_size);
-                compiler.stack_size += 1;
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += 1;
                 declared_vars.insert(var.clone());
                 instructions.push(IntermediateInstruction::CounterHint {
                     res_offset: compiler
@@ -594,6 +616,8 @@ fn compile_lines(
         }
     }
 
+    compiler.stack_size = compiler.stack_size.max(compiler.stack_pos);
+
     if let Some(jump_label) = final_jump {
         instructions.push(IntermediateInstruction::Jump {
             dest: IntermediateValue::label(jump_label),
@@ -612,18 +636,14 @@ fn handle_const_malloc(
     size: usize,
     label: &ConstMallocLabel,
 ) {
-    declared_vars.insert(var.clone());
     instructions.push(IntermediateInstruction::Computation {
         operation: Operation::Add,
-        arg_a: IntermediateValue::Constant(compiler.stack_size.into()),
+        arg_a: IntermediateValue::Constant(compiler.stack_pos.into()),
         arg_c: IntermediateValue::Fp,
         res: IntermediateValue::MemoryAfterFp {
             offset: compiler.get_offset(&var.clone().into()),
         },
     });
-    let current_scope = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-    current_scope.const_mallocs.insert(*label, compiler.stack_size);
-    compiler.stack_size += size;
 }
 
 // Helper functions

From f4eeb71a05cb601fc25fff65767c3519f2f40d63 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Mon, 1 Dec 2025 19:42:03 +0000
Subject: [PATCH 06/20] wip: issue/88

---
 crates/lean_compiler/src/b_compile_intermediate.rs | 11 ++++++++++-
 crates/lean_vm/src/diagnostics/error.rs            |  4 ++--
 crates/lean_vm/src/execution/memory.rs             |  2 +-
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 861a64ed..41d509c1 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -33,6 +33,15 @@ struct ScopeLayout {
 }
 
 impl Compiler {
+    fn is_in_scope(&self, var: &Var) -> bool {
+        for scope in self.stack_frame_layout.scopes.iter() {
+            if let Some(_offset) = scope.var_positions.get(var) {
+                return true;
+            }
+        }
+        false
+    }
+
     fn get_offset(&self, var: &VarOrConstMallocAccess) -> ConstExpression {
         match var {
             VarOrConstMallocAccess::Var(var) => {
@@ -392,7 +401,7 @@ fn compile_lines(
             SimpleLine::RawAccess { res, index, shift } => {
                 // TODO: why is validate_vars_declared here?
                 validate_vars_declared(&[index], declared_vars)?;
-                if let SimpleExpr::Var(var) = res {
+                if let SimpleExpr::Var(var) = res && !compiler.is_in_scope(var) {
                     declared_vars.insert(var.clone());
                     let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
diff --git a/crates/lean_vm/src/diagnostics/error.rs b/crates/lean_vm/src/diagnostics/error.rs
index 1659d3c9..c18ab185 100644
--- a/crates/lean_vm/src/diagnostics/error.rs
+++ b/crates/lean_vm/src/diagnostics/error.rs
@@ -25,8 +25,8 @@ pub enum RunnerError {
     #[error("Computation invalid: {0} != {1}")]
     NotEqual(F, F),
 
-    #[error("Undefined memory access")]
-    UndefinedMemory,
+    #[error("Undefined memory access: {0}")]
+    UndefinedMemory(usize),
 
     #[error("Program counter out of bounds")]
     PCOutOfBounds,
diff --git a/crates/lean_vm/src/execution/memory.rs b/crates/lean_vm/src/execution/memory.rs
index a162fb46..00a685d9 100644
--- a/crates/lean_vm/src/execution/memory.rs
+++ b/crates/lean_vm/src/execution/memory.rs
@@ -25,7 +25,7 @@ impl Memory {
     ///
     /// Returns an error if the address is uninitialized
     pub fn get(&self, index: usize) -> Result<F, RunnerError> {
-        self.0.get(index).copied().flatten().ok_or(RunnerError::UndefinedMemory)
+        self.0.get(index).copied().flatten().ok_or(RunnerError::UndefinedMemory(index))
     }
 
     /// Sets a value at a memory address

From 10d2ed2de062e3c8e8a0edc6636539871654f41d Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 2 Dec 2025 16:02:03 +0000
Subject: [PATCH 07/20] wip: issue/88

---
 crates/lean_compiler/src/b_compile_intermediate.rs | 5 +++--
 crates/lean_compiler/tests/test_compiler.rs        | 8 ++++----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 41d509c1..e8b7213e 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -539,9 +539,10 @@ fn compile_lines(
                 declared_vars.insert(var.clone());
                 let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                current_scope_layout.const_mallocs.insert(*label, compiler.stack_pos + 1);
-                compiler.stack_pos += 1 + size;
+                compiler.stack_pos += 1;
+                current_scope_layout.const_mallocs.insert(*label, compiler.stack_pos);
                 handle_const_malloc(declared_vars, &mut instructions, compiler, var, size, label);
+                compiler.stack_pos += size;
             }
             SimpleLine::DecomposeBits {
                 var,
diff --git a/crates/lean_compiler/tests/test_compiler.rs b/crates/lean_compiler/tests/test_compiler.rs
index cf9edafa..285cdd5e 100644
--- a/crates/lean_compiler/tests/test_compiler.rs
+++ b/crates/lean_compiler/tests/test_compiler.rs
@@ -385,10 +385,10 @@ fn test_inlined() {
 fn test_match() {
     let program = r#"
     fn main() {
-        for x in 0..3 unroll {
+        for x in 0..3 {
             func_match(x);
         }
-        for x in 0..2 unroll {
+        for x in 0..2 {
             match x {
                 0 => {
                     y = 10 * (x + 8);
@@ -405,7 +405,7 @@ fn test_match() {
         return;
     }
 
-    fn func_match(x) inline {
+    fn func_match(x) {
         match x {
             0 => {
                 print(41);
@@ -426,7 +426,7 @@ fn test_match() {
         return x * x * x * x;
     }
 
-    fn func_2(x) inline -> 1 {
+    fn func_2(x) -> 1 {
         return x * x * x * x * x * x;
     }
    "#;

From b175780b38ed0f9046455680ce181601fcda2334 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 2 Dec 2025 23:19:44 +0000
Subject: [PATCH 08/20] shrink test_match

---
 crates/lean_compiler/tests/test_compiler.rs | 24 +--------------------
 1 file changed, 1 insertion(+), 23 deletions(-)

diff --git a/crates/lean_compiler/tests/test_compiler.rs b/crates/lean_compiler/tests/test_compiler.rs
index 285cdd5e..530fb000 100644
--- a/crates/lean_compiler/tests/test_compiler.rs
+++ b/crates/lean_compiler/tests/test_compiler.rs
@@ -385,23 +385,7 @@ fn test_inlined() {
 fn test_match() {
     let program = r#"
     fn main() {
-        for x in 0..3 {
-            func_match(x);
-        }
-        for x in 0..2 {
-            match x {
-                0 => {
-                    y = 10 * (x + 8);
-                    z = 10 * y;
-                    print(z);
-                }
-                1 => {
-                    y = 10 * x;
-                    z = func_2(y);
-                    print(z);
-                }
-            }
-        }
+        func_match(1);
         return;
     }
 
@@ -415,8 +399,6 @@ fn test_match() {
                 print(y + 1);
             }
             2 => {
-                y = 10 * x;
-                print(y);
             }
         }
         return;
@@ -425,10 +407,6 @@ fn test_match() {
     fn func_1(x) -> 1 {
         return x * x * x * x;
     }
-
-    fn func_2(x) -> 1 {
-        return x * x * x * x * x * x;
-    }
    "#;
     compile_and_run(program.to_string(), (&[], &[]), DEFAULT_NO_VEC_RUNTIME_MEMORY, false);
 }

From d9ea883b96c2fe5524af14a91cd632543679d3cf Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Wed, 3 Dec 2025 15:46:08 +0000
Subject: [PATCH 09/20] wip: issue/88

---
 .../src/b_compile_intermediate.rs             | 61 ++++++++++---------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index e8b7213e..73923a18 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -129,7 +129,7 @@ fn compile_function(
 ) -> Result<Vec<IntermediateInstruction>, String> {
     // memory layout: pc, fp, args, return_vars, internal_vars
     let mut stack_pos = 2; // Reserve space for pc and fp
-    let mut function_scope_layout = ScopeLayout::default();
+    let function_scope_layout = ScopeLayout::default();
     compiler.stack_frame_layout = StackFrameLayout {
         scopes: vec![function_scope_layout],
     };
@@ -212,7 +212,6 @@ fn compile_lines(
             }
 
             SimpleLine::Match { value, arms } => {
-                let saved_stack_pos = compiler.stack_pos;
                 compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
 
                 let match_index = compiler.match_blocks.len();
@@ -221,6 +220,8 @@ fn compile_lines(
                 let value_simplified = IntermediateValue::from_simple_expr(value, compiler);
 
                 let mut compiled_arms = vec![];
+                let saved_stack_pos = compiler.stack_pos;
+                let mut new_stack_pos = saved_stack_pos;
                 for (i, arm) in arms.iter().enumerate() {
                     let mut arm_declared_vars = declared_vars.clone();
                     compiler.stack_pos = saved_stack_pos;
@@ -237,7 +238,9 @@ fn compile_lines(
                     } else {
                         declared_vars.intersection(&arm_declared_vars).cloned().collect()
                     };
+                    new_stack_pos = new_stack_pos.max(compiler.stack_pos);
                 }
+                compiler.stack_pos = new_stack_pos;
                 compiler.match_blocks.push(MatchBlock {
                     function_name: function_name.clone(),
                     match_cases: compiled_arms,
@@ -549,6 +552,11 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
+                declared_vars.insert(var.clone());
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += 1;
+
                 instructions.push(IntermediateInstruction::DecomposeBits {
                     res_offset: compiler.stack_pos,
                     to_decompose: to_decompose
@@ -556,26 +564,27 @@ fn compile_lines(
                         .map(|expr| IntermediateValue::from_simple_expr(expr, compiler))
                         .collect(),
                 });
-                declared_vars.insert(var.clone());
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += F::bits() * to_decompose.len();
 
-                // TODO: is handle_const_malloc needed?
-                // handle_const_malloc(
-                //     declared_vars,
-                //     &mut instructions,
-                //     compiler,
-                //     var,
-                //     F::bits() * to_decompose.len(),
-                //     label,
-                // );
+                handle_const_malloc(
+                    declared_vars,
+                    &mut instructions,
+                    compiler,
+                    var,
+                    F::bits() * to_decompose.len(),
+                    label,
+                );
+                compiler.stack_pos += F::bits() * to_decompose.len();
             }
             SimpleLine::DecomposeCustom {
                 var,
                 to_decompose,
                 label,
             } => {
+                declared_vars.insert(var.clone());
+                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                compiler.stack_pos += 1;
+
                 instructions.push(IntermediateInstruction::DecomposeCustom {
                     res_offset: compiler.stack_pos,
                     to_decompose: to_decompose
@@ -583,20 +592,16 @@ fn compile_lines(
                         .map(|expr| IntermediateValue::from_simple_expr(expr, compiler))
                         .collect(),
                 });
-                declared_vars.insert(var.clone());
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += F::bits() * to_decompose.len();
 
-                // TODO: is handle_const_malloc needed?
-                // handle_const_malloc(
-                //     declared_vars,
-                //     &mut instructions,
-                //     compiler,
-                //     var,
-                //     F::bits() * to_decompose.len(),
-                //     label,
-                // );
+                handle_const_malloc(
+                    declared_vars,
+                    &mut instructions,
+                    compiler,
+                    var,
+                    F::bits() * to_decompose.len(),
+                    label,
+                );
+                compiler.stack_pos += F::bits() * to_decompose.len();
             }
             SimpleLine::CounterHint { var } => {
                 let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();

From 4f17aadf4848f44f02e83b9731071e489f02ae9e Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Wed, 3 Dec 2025 16:49:59 +0000
Subject: [PATCH 10/20] remove mark_vars_as_declared

---
 crates/lean_compiler/src/b_compile_intermediate.rs | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 73923a18..a947cb38 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -180,7 +180,6 @@ fn compile_lines(
                 arg0,
                 arg1,
             } => {
-                mark_vars_as_declared(&[arg0, arg1], declared_vars);
                 let arg0 = IntermediateValue::from_simple_expr(arg0, compiler);
                 let arg1 = IntermediateValue::from_simple_expr(arg1, compiler);
 
@@ -206,9 +205,6 @@ fn compile_lines(
                     IntermediateValue::from_simple_expr(arg1, compiler),
                     IntermediateValue::Constant(0.into()),
                 ));
-
-                // TODO: why is mark_vars_as_declared here?
-                mark_vars_as_declared(&[arg0, arg1], declared_vars);
             }
 
             SimpleLine::Match { value, arms } => {
@@ -662,14 +658,6 @@ fn handle_const_malloc(
 }
 
 // Helper functions
-fn mark_vars_as_declared<VoC: Borrow<SimpleExpr>>(vocs: &[VoC], declared: &mut BTreeSet<Var>) {
-    for voc in vocs {
-        if let SimpleExpr::Var(v) = voc.borrow() {
-            declared.insert(v.clone());
-        }
-    }
-}
-
 fn validate_vars_declared<VoC: Borrow<SimpleExpr>>(vocs: &[VoC], declared: &BTreeSet<Var>) -> Result<(), String> {
     for voc in vocs {
         if let SimpleExpr::Var(v) = voc.borrow()

From 9a1e86a1543729e6fa68426bfde35f5627ef9f50 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Wed, 3 Dec 2025 16:54:14 +0000
Subject: [PATCH 11/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs   |  2 +-
 .../src/b_compile_intermediate.rs             | 32 +++++++++----------
 .../src/parser/parsers/statement.rs           |  2 +-
 crates/lean_vm/src/execution/tests.rs         |  4 +--
 .../recursion_program.lean_lang               |  2 ++
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index bcd068db..efeb6453 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -326,7 +326,7 @@ fn check_expr_scoping(expr: &Expression, ctx: &Context) {
 fn check_simple_expr_scoping(expr: &SimpleExpr, ctx: &Context) {
     match expr {
         SimpleExpr::Var(v) => {
-            assert!(ctx.defines(&v), "Variable defined but not used: {:?}", v)
+            assert!(ctx.defines(&v), "Variable used but not defined: {:?}", v)
         },
         SimpleExpr::Constant(_) => {},
         SimpleExpr::ConstMallocAccess { .. } => {},
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index a947cb38..0a515304 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -169,8 +169,9 @@ fn compile_lines(
     for (i, line) in lines.iter().enumerate() {
         match line {
             SimpleLine::ForwardDeclaration { var } => {
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                declared_vars.insert(var.clone());
                 compiler.stack_pos += 1;
             }
 
@@ -185,7 +186,7 @@ fn compile_lines(
 
                 if let VarOrConstMallocAccess::Var(var) = var {
                     declared_vars.insert(var.clone());
-                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
@@ -402,7 +403,7 @@ fn compile_lines(
                 validate_vars_declared(&[index], declared_vars)?;
                 if let SimpleExpr::Var(var) = res && !compiler.is_in_scope(var) {
                     declared_vars.insert(var.clone());
-                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
@@ -442,8 +443,9 @@ fn compile_lines(
                 validate_vars_declared(args, declared_vars)?;
                 declared_vars.extend(return_data.iter().cloned());
                 for var in return_data.iter() {
-                    let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    declared_vars.insert(var.clone());
                     compiler.stack_pos += 1;
                 }
 
@@ -522,7 +524,7 @@ fn compile_lines(
                 vectorized,
                 vectorized_len,
             } => {
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
                 declared_vars.insert(var.clone());
@@ -536,12 +538,10 @@ fn compile_lines(
             SimpleLine::ConstMalloc { var, size, label } => {
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
                 declared_vars.insert(var.clone());
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
-                current_scope_layout.const_mallocs.insert(*label, compiler.stack_pos);
-                handle_const_malloc(declared_vars, &mut instructions, compiler, var, size, label);
-                compiler.stack_pos += size;
+                handle_const_malloc(&mut instructions, compiler, var, size, label);
             }
             SimpleLine::DecomposeBits {
                 var,
@@ -549,7 +549,7 @@ fn compile_lines(
                 label,
             } => {
                 declared_vars.insert(var.clone());
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
 
@@ -562,14 +562,12 @@ fn compile_lines(
                 });
 
                 handle_const_malloc(
-                    declared_vars,
                     &mut instructions,
                     compiler,
                     var,
                     F::bits() * to_decompose.len(),
                     label,
                 );
-                compiler.stack_pos += F::bits() * to_decompose.len();
             }
             SimpleLine::DecomposeCustom {
                 var,
@@ -577,7 +575,7 @@ fn compile_lines(
                 label,
             } => {
                 declared_vars.insert(var.clone());
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
 
@@ -590,17 +588,15 @@ fn compile_lines(
                 });
 
                 handle_const_malloc(
-                    declared_vars,
                     &mut instructions,
                     compiler,
                     var,
                     F::bits() * to_decompose.len(),
                     label,
                 );
-                compiler.stack_pos += F::bits() * to_decompose.len();
             }
             SimpleLine::CounterHint { var } => {
-                let mut current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
                 declared_vars.insert(var.clone());
@@ -640,13 +636,14 @@ fn compile_lines(
 }
 
 fn handle_const_malloc(
-    declared_vars: &mut BTreeSet<Var>,
     instructions: &mut Vec<IntermediateInstruction>,
     compiler: &mut Compiler,
     var: &Var,
     size: usize,
     label: &ConstMallocLabel,
 ) {
+    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+    current_scope_layout.const_mallocs.insert(*label, compiler.stack_pos);
     instructions.push(IntermediateInstruction::Computation {
         operation: Operation::Add,
         arg_a: IntermediateValue::Constant(compiler.stack_pos.into()),
@@ -655,6 +652,7 @@ fn handle_const_malloc(
             offset: compiler.get_offset(&var.clone().into()),
         },
     });
+    compiler.stack_pos += size;
 }
 
 // Helper functions
diff --git a/crates/lean_compiler/src/parser/parsers/statement.rs b/crates/lean_compiler/src/parser/parsers/statement.rs
index 983acf93..094d963f 100644
--- a/crates/lean_compiler/src/parser/parsers/statement.rs
+++ b/crates/lean_compiler/src/parser/parsers/statement.rs
@@ -40,7 +40,7 @@ impl Parse<Line> for StatementParser {
 pub struct ForwardDeclarationParser;
 
 impl Parse<Line> for ForwardDeclarationParser {
-    fn parse(pair: ParsePair<'_>, ctx: &mut ParseContext) -> ParseResult<Line> {
+    fn parse(pair: ParsePair<'_>, _ctx: &mut ParseContext) -> ParseResult<Line> {
         let mut inner = pair.into_inner();
         let var = next_inner_pair(&mut inner, "variable name")?.as_str().to_string();
         Ok(Line::ForwardDeclaration { var })
diff --git a/crates/lean_vm/src/execution/tests.rs b/crates/lean_vm/src/execution/tests.rs
index ca03ba2c..92c16fd6 100644
--- a/crates/lean_vm/src/execution/tests.rs
+++ b/crates/lean_vm/src/execution/tests.rs
@@ -13,7 +13,7 @@ fn test_basic_memory_operations() {
     assert_eq!(memory.get(5).unwrap(), F::from_usize(42));
 
     // Test undefined memory access
-    assert!(matches!(memory.get(1), Err(RunnerError::UndefinedMemory)));
+    assert!(matches!(memory.get(1), Err(RunnerError::UndefinedMemory(1))));
 }
 
 #[test]
@@ -25,7 +25,7 @@ fn test_memory_already_set_error() {
     memory.set(0, F::ONE).unwrap();
 
     // Setting different value should fail
-    assert!(matches!(memory.set(0, F::ZERO), Err(RunnerError::MemoryAlreadySet)));
+    assert!(matches!(memory.set(0, F::ZERO), Err(RunnerError::MemoryAlreadySet { address: 0, prev_value: F::ONE, new_value: F::ZERO })));
 }
 
 #[test]
diff --git a/crates/rec_aggregation/recursion_program.lean_lang b/crates/rec_aggregation/recursion_program.lean_lang
index 3c5b62a6..4f13a9aa 100644
--- a/crates/rec_aggregation/recursion_program.lean_lang
+++ b/crates/rec_aggregation/recursion_program.lean_lang
@@ -334,6 +334,8 @@ fn sample_stir_indexes_and_fold(fs_state, num_queries, merkle_leaves_in_basefiel
         states = malloc(1 + folded_domain_size);
         states[0] = leaf_hashes[i];
         for j in 0..folded_domain_size {
+            var left;
+            var right;
             if stir_index_bits[j] == 1 {
                 left = merkle_path + j;
                 right = states[j];

From 7c95321996c8e51f6114a87c370ed20c9d4b52e7 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Thu, 4 Dec 2025 15:29:10 +0000
Subject: [PATCH 12/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index efeb6453..d733ce8c 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -1597,6 +1597,10 @@ fn handle_inlined_functions_helper(
                 if let Some(func) = inlined_functions.get(&*function_name) {
                     let mut inlined_lines = vec![];
 
+                    for var in return_data.iter() {
+                        inlined_lines.push(Line::ForwardDeclaration { var : var.clone() });
+                    }
+
                     let mut simplified_args = vec![];
                     for arg in args {
                         if let Expression::Value(simple_expr) = arg {

From f659f6791f1316c6d691979f0bb71318d96d0f40 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Fri, 5 Dec 2025 00:20:53 +0000
Subject: [PATCH 13/20] wip: issue/88

---
 crates/lean_vm/src/diagnostics/stack_trace.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/lean_vm/src/diagnostics/stack_trace.rs b/crates/lean_vm/src/diagnostics/stack_trace.rs
index c3b4487e..2fe17230 100644
--- a/crates/lean_vm/src/diagnostics/stack_trace.rs
+++ b/crates/lean_vm/src/diagnostics/stack_trace.rs
@@ -97,7 +97,7 @@ pub(crate) fn pretty_stack_trace(
 
     if !call_stack.is_empty() {
         result.push_str("\nCall stack:\n");
-        for (i, (line, func)) in call_stack.iter().enumerate() {
+        for (i, (line, func)) in call_stack.iter().rev().enumerate() {
             if i + 1 == call_stack.len() {
                 result.push_str(&format!("  {}. {} (line {}, pc {})\n", i + 1, func, line, last_pc));
             } else {

From 5a97dcd3395d72f078d304cf87a9cc73de9e8a95 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Mon, 8 Dec 2025 15:56:04 +0000
Subject: [PATCH 14/20] reverse stack trace order

---
 crates/lean_vm/src/diagnostics/stack_trace.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/lean_vm/src/diagnostics/stack_trace.rs b/crates/lean_vm/src/diagnostics/stack_trace.rs
index 2fe17230..c3b4487e 100644
--- a/crates/lean_vm/src/diagnostics/stack_trace.rs
+++ b/crates/lean_vm/src/diagnostics/stack_trace.rs
@@ -97,7 +97,7 @@ pub(crate) fn pretty_stack_trace(
 
     if !call_stack.is_empty() {
         result.push_str("\nCall stack:\n");
-        for (i, (line, func)) in call_stack.iter().rev().enumerate() {
+        for (i, (line, func)) in call_stack.iter().enumerate() {
             if i + 1 == call_stack.len() {
                 result.push_str(&format!("  {}. {} (line {}, pc {})\n", i + 1, func, line, last_pc));
             } else {

From 24238429ae883a8edb92f67526d0e51238e7026f Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Mon, 8 Dec 2025 22:00:37 +0000
Subject: [PATCH 15/20] add failing test case from shrinking WHIR recursion

---
 crates/lean_compiler/tests/test_compiler.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/crates/lean_compiler/tests/test_compiler.rs b/crates/lean_compiler/tests/test_compiler.rs
index 530fb000..e49a6a4a 100644
--- a/crates/lean_compiler/tests/test_compiler.rs
+++ b/crates/lean_compiler/tests/test_compiler.rs
@@ -381,6 +381,27 @@ fn test_inlined() {
     compile_and_run(program.to_string(), (&[], &[]), DEFAULT_NO_VEC_RUNTIME_MEMORY, false);
 }
 
+#[test]
+fn test_inlined_2() {
+    let program = r#"
+    fn main() {
+        b = is_one();
+        c = b;
+        return;
+    }
+
+    fn is_one() inline -> 1 {
+        if 1 {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+   "#;
+    compile_and_run(program.to_string(), (&[], &[]), DEFAULT_NO_VEC_RUNTIME_MEMORY, false);
+
+}
+
 #[test]
 fn test_match() {
     let program = r#"

From 8bcc808b96625c2c4ce643be59a2e3c0c190106c Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 9 Dec 2025 01:46:28 +0000
Subject: [PATCH 16/20] wip: issue/88: bugfix: eliminate name shadowing

---
 .../src/b_compile_intermediate.rs             | 64 +++++++++++--------
 1 file changed, 38 insertions(+), 26 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 0a515304..42033522 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -184,7 +184,7 @@ fn compile_lines(
                 let arg0 = IntermediateValue::from_simple_expr(arg0, compiler);
                 let arg1 = IntermediateValue::from_simple_expr(arg1, compiler);
 
-                if let VarOrConstMallocAccess::Var(var) = var {
+                if let VarOrConstMallocAccess::Var(var) = var && !compiler.is_in_scope(var) {
                     declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
@@ -230,7 +230,7 @@ fn compile_lines(
                         &mut arm_declared_vars,
                     )?;
                     compiled_arms.push(arm_instructions);
-                    *declared_vars = if i == 0 {
+                    *declared_vars = if i == 0 { // TODO: is this right?
                         arm_declared_vars
                     } else {
                         declared_vars.intersection(&arm_declared_vars).cloned().collect()
@@ -443,10 +443,12 @@ fn compile_lines(
                 validate_vars_declared(args, declared_vars)?;
                 declared_vars.extend(return_data.iter().cloned());
                 for var in return_data.iter() {
-                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                    declared_vars.insert(var.clone());
-                    compiler.stack_pos += 1;
+                    if !compiler.is_in_scope(var) {
+                        let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                        current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                        declared_vars.insert(var.clone());
+                        compiler.stack_pos += 1;
+                    }
                 }
 
                 let after_call = {
@@ -524,10 +526,12 @@ fn compile_lines(
                 vectorized,
                 vectorized_len,
             } => {
-                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += 1;
-                declared_vars.insert(var.clone());
+                if !compiler.is_in_scope(var) {
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
+                    declared_vars.insert(var.clone());
+                }
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
                     size: IntermediateValue::from_simple_expr(size, compiler),
@@ -537,10 +541,12 @@ fn compile_lines(
             }
             SimpleLine::ConstMalloc { var, size, label } => {
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
-                declared_vars.insert(var.clone());
-                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += 1;
+                if !compiler.is_in_scope(var) {
+                    declared_vars.insert(var.clone());
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
+                }
                 handle_const_malloc(&mut instructions, compiler, var, size, label);
             }
             SimpleLine::DecomposeBits {
@@ -548,10 +554,12 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
-                declared_vars.insert(var.clone());
-                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += 1;
+                if !compiler.is_in_scope(var) {
+                    declared_vars.insert(var.clone());
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
+                }
 
                 instructions.push(IntermediateInstruction::DecomposeBits {
                     res_offset: compiler.stack_pos,
@@ -574,10 +582,12 @@ fn compile_lines(
                 to_decompose,
                 label,
             } => {
-                declared_vars.insert(var.clone());
-                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += 1;
+                if !compiler.is_in_scope(var) {
+                    declared_vars.insert(var.clone());
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
+                }
 
                 instructions.push(IntermediateInstruction::DecomposeCustom {
                     res_offset: compiler.stack_pos,
@@ -596,10 +606,12 @@ fn compile_lines(
                 );
             }
             SimpleLine::CounterHint { var } => {
-                let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                compiler.stack_pos += 1;
-                declared_vars.insert(var.clone());
+                if !compiler.is_in_scope(var) {
+                    let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
+                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    compiler.stack_pos += 1;
+                    declared_vars.insert(var.clone());
+                }
                 instructions.push(IntermediateInstruction::CounterHint {
                     res_offset: compiler
                         .get_offset(&var.clone().into())

From fb43d0ed0fe78c70da4284b16e1e330bc57bb3e2 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 9 Dec 2025 02:09:03 +0000
Subject: [PATCH 17/20] refactor: remove declared_vars

---
 .../src/b_compile_intermediate.rs             | 47 +------------------
 1 file changed, 2 insertions(+), 45 deletions(-)

diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 42033522..a1ebefe0 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -147,13 +147,11 @@ fn compile_function(
     compiler.stack_size = stack_pos;
     compiler.args_count = function.arguments.len();
 
-    let mut declared_vars: BTreeSet<Var> = function.arguments.iter().cloned().collect();
     compile_lines(
         &Label::function(function.name.clone()),
         &function.instructions,
         compiler,
         None,
-        &mut declared_vars,
     )
 }
 
@@ -162,7 +160,6 @@ fn compile_lines(
     lines: &[SimpleLine],
     compiler: &mut Compiler,
     final_jump: Option<Label>,
-    declared_vars: &mut BTreeSet<Var>,
 ) -> Result<Vec<IntermediateInstruction>, String> {
     let mut instructions = Vec::new();
 
@@ -171,7 +168,6 @@ fn compile_lines(
             SimpleLine::ForwardDeclaration { var } => {
                 let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                 current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                declared_vars.insert(var.clone());
                 compiler.stack_pos += 1;
             }
 
@@ -185,7 +181,6 @@ fn compile_lines(
                 let arg1 = IntermediateValue::from_simple_expr(arg1, compiler);
 
                 if let VarOrConstMallocAccess::Var(var) = var && !compiler.is_in_scope(var) {
-                    declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
@@ -220,21 +215,14 @@ fn compile_lines(
                 let saved_stack_pos = compiler.stack_pos;
                 let mut new_stack_pos = saved_stack_pos;
                 for (i, arm) in arms.iter().enumerate() {
-                    let mut arm_declared_vars = declared_vars.clone();
                     compiler.stack_pos = saved_stack_pos;
                     let arm_instructions = compile_lines(
                         function_name,
                         arm,
                         compiler,
                         Some(end_label.clone()),
-                        &mut arm_declared_vars,
                     )?;
                     compiled_arms.push(arm_instructions);
-                    *declared_vars = if i == 0 { // TODO: is this right?
-                        arm_declared_vars
-                    } else {
-                        declared_vars.intersection(&arm_declared_vars).cloned().collect()
-                    };
                     new_stack_pos = new_stack_pos.max(compiler.stack_pos);
                 }
                 compiler.stack_pos = new_stack_pos;
@@ -269,7 +257,7 @@ fn compile_lines(
                     updated_fp: None,
                 });
 
-                let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump, declared_vars)?;
+                let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump)?;
                 compiler.bytecode.insert(end_label, remaining);
 
                 compiler.stack_frame_layout.scopes.pop();
@@ -288,8 +276,6 @@ fn compile_lines(
             } => {
                 compiler.stack_frame_layout.scopes.push(ScopeLayout::default());
 
-                validate_vars_declared(&[condition], declared_vars)?;
-
                 let if_id = compiler.if_counter;
                 compiler.if_counter += 1;
 
@@ -364,24 +350,20 @@ fn compile_lines(
 
                 let saved_stack_pos = compiler.stack_pos;
 
-                let mut then_declared_vars = declared_vars.clone();
                 let then_instructions = compile_lines(
                     function_name,
                     then_branch,
                     compiler,
                     Some(end_label.clone()),
-                    &mut then_declared_vars,
                 )?;
 
                 let then_stack_pos = compiler.stack_pos;
                 compiler.stack_pos = saved_stack_pos;
-                let mut else_declared_vars = declared_vars.clone();
                 let else_instructions = compile_lines(
                     function_name,
                     else_branch,
                     compiler,
                     Some(end_label.clone()),
-                    &mut else_declared_vars,
                 )?;
 
                 compiler.bytecode.insert(if_label, then_instructions);
@@ -390,7 +372,7 @@ fn compile_lines(
                 compiler.stack_frame_layout.scopes.pop();
                 compiler.stack_pos = compiler.stack_pos.max(then_stack_pos);
 
-                let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump, declared_vars)?;
+                let remaining = compile_lines(function_name, &lines[i + 1..], compiler, final_jump)?;
                 compiler.bytecode.insert(end_label, remaining);
                 // It is not necessary to update compiler.stack_size here because the preceding call to
                 // compile_lines should have done so.
@@ -399,10 +381,7 @@ fn compile_lines(
             }
 
             SimpleLine::RawAccess { res, index, shift } => {
-                // TODO: why is validate_vars_declared here?
-                validate_vars_declared(&[index], declared_vars)?;
                 if let SimpleExpr::Var(var) = res && !compiler.is_in_scope(var) {
-                    declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
@@ -439,14 +418,10 @@ fn compile_lines(
                     compiler,
                 )?);
 
-                // TODO: why is validate_vars_declared here?
-                validate_vars_declared(args, declared_vars)?;
-                declared_vars.extend(return_data.iter().cloned());
                 for var in return_data.iter() {
                     if !compiler.is_in_scope(var) {
                         let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                         current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
-                        declared_vars.insert(var.clone());
                         compiler.stack_pos += 1;
                     }
                 }
@@ -470,7 +445,6 @@ fn compile_lines(
                         &lines[i + 1..],
                         compiler,
                         final_jump,
-                        declared_vars,
                     )?);
 
                     instructions
@@ -530,7 +504,6 @@ fn compile_lines(
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
-                    declared_vars.insert(var.clone());
                 }
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
@@ -542,7 +515,6 @@ fn compile_lines(
             SimpleLine::ConstMalloc { var, size, label } => {
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
                 if !compiler.is_in_scope(var) {
-                    declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
@@ -555,7 +527,6 @@ fn compile_lines(
                 label,
             } => {
                 if !compiler.is_in_scope(var) {
-                    declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
@@ -583,7 +554,6 @@ fn compile_lines(
                 label,
             } => {
                 if !compiler.is_in_scope(var) {
-                    declared_vars.insert(var.clone());
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
@@ -610,7 +580,6 @@ fn compile_lines(
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
                     current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
-                    declared_vars.insert(var.clone());
                 }
                 instructions.push(IntermediateInstruction::CounterHint {
                     res_offset: compiler
@@ -667,18 +636,6 @@ fn handle_const_malloc(
     compiler.stack_pos += size;
 }
 
-// Helper functions
-fn validate_vars_declared<VoC: Borrow<SimpleExpr>>(vocs: &[VoC], declared: &BTreeSet<Var>) -> Result<(), String> {
-    for voc in vocs {
-        if let SimpleExpr::Var(v) = voc.borrow()
-            && !declared.contains(v)
-        {
-            return Err(format!("Variable {v} not declared"));
-        }
-    }
-    Ok(())
-}
-
 fn setup_function_call(
     func_name: &str,
     args: &[SimpleExpr],

From e12428b5a34a179518b991873430e4f8a298658f Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 9 Dec 2025 02:14:18 +0000
Subject: [PATCH 18/20] wip: issue/88

---
 crates/lean_compiler/src/a_simplify_lang.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index d733ce8c..b6ec8405 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -636,8 +636,6 @@ fn simplify_lines(
                     counter: const_malloc.counter,
                     ..ConstMalloc::default()
                 };
-                // TODO: what is array manager, and does it need to be updated
-                // to make block-level scoping work?
                 let valid_aux_vars_in_array_manager_before = array_manager.valid.clone();
                 array_manager.valid.clear();
                 let simplified_body = simplify_lines(

From 07221b245c000a50634d300bc9a5d404681d8392 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 9 Dec 2025 02:15:10 +0000
Subject: [PATCH 19/20] cargo fmt

---
 crates/lean_compiler/src/a_simplify_lang.rs   | 137 ++++++++++++------
 .../src/b_compile_intermediate.rs             |  92 ++++++------
 crates/lean_compiler/src/lang.rs              |   4 +-
 crates/lean_compiler/tests/test_compiler.rs   |   1 -
 crates/lean_vm/src/execution/memory.rs        |   6 +-
 crates/lean_vm/src/execution/runner.rs        |   4 +-
 crates/lean_vm/src/execution/tests.rs         |   9 +-
 7 files changed, 155 insertions(+), 98 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index b6ec8405..680aa860 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -2,8 +2,8 @@ use crate::{
     Counter, F,
     ir::HighLevelOperation,
     lang::{
-        AssumeBoolean, Boolean, Condition, ConstExpression, ConstMallocLabel, ConstantValue, Expression, Function,
-        Line, Program, SimpleExpr, Var, Context, Scope,
+        AssumeBoolean, Boolean, Condition, ConstExpression, ConstMallocLabel, ConstantValue, Context, Expression,
+        Function, Line, Program, Scope, SimpleExpr, Var,
     },
 };
 use lean_vm::{SourceLineNumber, Table, TableT};
@@ -72,7 +72,9 @@ pub enum SimpleLine {
         value: SimpleExpr,
         arms: Vec<Vec<Self>>, // patterns = 0, 1, ...
     },
-    ForwardDeclaration { var: Var },
+    ForwardDeclaration {
+        var: Var,
+    },
     Assignment {
         var: VarOrConstMallocAccess,
         operation: HighLevelOperation,
@@ -192,7 +194,7 @@ pub fn simplify_program(mut program: Program) -> SimpleProgram {
 }
 
 /// Analyzes the program to verify that each variable is defined in each context where it is used.
-fn check_program_scoping(program: &Program)  {
+fn check_program_scoping(program: &Program) {
     for (_, function) in program.functions.iter() {
         let mut scope = Scope { vars: BTreeSet::new() };
         for (arg, _) in function.arguments.iter() {
@@ -210,9 +212,13 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
         match line {
             Line::ForwardDeclaration { var } => {
                 let last_scope = ctx.scopes.last_mut().unwrap();
-                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                assert!(
+                    !last_scope.vars.contains(var),
+                    "Variable declared multiple times in the same scope: {:?}",
+                    var
+                );
                 last_scope.vars.insert(var.clone());
-            },
+            }
             Line::Match { value, arms } => {
                 check_expr_scoping(value, ctx);
                 for (_, arm) in arms {
@@ -220,30 +226,47 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                     check_block_scoping(arm, ctx);
                     ctx.scopes.pop();
                 }
-            },
+            }
             Line::Assignment { var, value } => {
                 check_expr_scoping(value, ctx);
                 let last_scope = ctx.scopes.last_mut().unwrap();
-                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                assert!(
+                    !last_scope.vars.contains(var),
+                    "Variable declared multiple times in the same scope: {:?}",
+                    var
+                );
                 last_scope.vars.insert(var.clone());
-              },
+            }
             Line::ArrayAssign { array, index, value } => {
                 check_simple_expr_scoping(array, ctx);
                 check_expr_scoping(index, ctx);
                 check_expr_scoping(value, ctx);
-            },
+            }
             Line::Assert(boolean, _) => {
                 check_boolean_scoping(boolean, ctx);
-            },
-            Line::IfCondition { condition, then_branch, else_branch, line_number: _ } => {
+            }
+            Line::IfCondition {
+                condition,
+                then_branch,
+                else_branch,
+                line_number: _,
+            } => {
                 check_condition_scoping(condition, ctx);
                 for branch in [then_branch, else_branch] {
                     ctx.scopes.push(Scope { vars: BTreeSet::new() });
                     check_block_scoping(branch, ctx);
                     ctx.scopes.pop();
                 }
-            },
-            Line::ForLoop { iterator, start, end, body, rev: _, unroll: _, line_number: _ } => {
+            }
+            Line::ForLoop {
+                iterator,
+                start,
+                end,
+                body,
+                rev: _,
+                unroll: _,
+                line_number: _,
+            } => {
                 check_expr_scoping(start, ctx);
                 check_expr_scoping(end, ctx);
                 let mut new_scope_vars = BTreeSet::new();
@@ -251,53 +274,79 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 ctx.scopes.push(Scope { vars: new_scope_vars });
                 check_block_scoping(body, ctx);
                 ctx.scopes.pop();
-            },
-            Line::FunctionCall { function_name: _, args, return_data, line_number: _ } => {
+            }
+            Line::FunctionCall {
+                function_name: _,
+                args,
+                return_data,
+                line_number: _,
+            } => {
                 for arg in args {
                     check_expr_scoping(arg, ctx);
                 }
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 for var in return_data {
-                    assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                    assert!(
+                        !last_scope.vars.contains(var),
+                        "Variable declared multiple times in the same scope: {:?}",
+                        var
+                    );
                     last_scope.vars.insert(var.clone());
                 }
-            },
+            }
             Line::FunctionRet { return_data } => {
                 for expr in return_data {
                     check_expr_scoping(expr, ctx);
                 }
-            },
+            }
             Line::Precompile { table: _, args } => {
                 for arg in args {
                     check_expr_scoping(arg, ctx);
                 }
-            },
-            Line::Break | Line::Panic | Line::LocationReport { .. } => {},
+            }
+            Line::Break | Line::Panic | Line::LocationReport { .. } => {}
             Line::Print { line_info: _, content } => {
                 for expr in content {
                     check_expr_scoping(expr, ctx);
                 }
-            },
-            Line::MAlloc { var, size, vectorized: _, vectorized_len } => {
+            }
+            Line::MAlloc {
+                var,
+                size,
+                vectorized: _,
+                vectorized_len,
+            } => {
                 check_expr_scoping(size, ctx);
                 check_expr_scoping(vectorized_len, ctx);
                 let last_scope = ctx.scopes.last_mut().unwrap();
-                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                assert!(
+                    !last_scope.vars.contains(var),
+                    "Variable declared multiple times in the same scope: {:?}",
+                    var
+                );
                 last_scope.vars.insert(var.clone());
-            },
+            }
             Line::DecomposeBits { var, to_decompose } | Line::DecomposeCustom { var, to_decompose } => {
                 for expr in to_decompose {
                     check_expr_scoping(expr, ctx);
                 }
                 let last_scope = ctx.scopes.last_mut().unwrap();
-                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                assert!(
+                    !last_scope.vars.contains(var),
+                    "Variable declared multiple times in the same scope: {:?}",
+                    var
+                );
                 last_scope.vars.insert(var.clone());
-            },
+            }
             Line::CounterHint { var } => {
                 let last_scope = ctx.scopes.last_mut().unwrap();
-                assert!(!last_scope.vars.contains(var), "Variable declared multiple times in the same scope: {:?}", var);
+                assert!(
+                    !last_scope.vars.contains(var),
+                    "Variable declared multiple times in the same scope: {:?}",
+                    var
+                );
                 last_scope.vars.insert(var.clone());
-            },
+            }
         }
     }
 }
@@ -307,18 +356,22 @@ fn check_expr_scoping(expr: &Expression, ctx: &Context) {
     match expr {
         Expression::Value(simple_expr) => {
             check_simple_expr_scoping(simple_expr, ctx);
-        },
+        }
         Expression::ArrayAccess { array, index } => {
             check_simple_expr_scoping(array, ctx);
             check_expr_scoping(&*index, ctx);
-        },
-        Expression::Binary { left, operation: _, right } => {
+        }
+        Expression::Binary {
+            left,
+            operation: _,
+            right,
+        } => {
             check_expr_scoping(&*left, ctx);
             check_expr_scoping(&*right, ctx);
-        },
+        }
         Expression::Log2Ceil { value } => {
             check_expr_scoping(&*value, ctx);
-        },
+        }
     }
 }
 
@@ -327,9 +380,9 @@ fn check_simple_expr_scoping(expr: &SimpleExpr, ctx: &Context) {
     match expr {
         SimpleExpr::Var(v) => {
             assert!(ctx.defines(&v), "Variable used but not defined: {:?}", v)
-        },
-        SimpleExpr::Constant(_) => {},
-        SimpleExpr::ConstMallocAccess { .. } => {},
+        }
+        SimpleExpr::Constant(_) => {}
+        SimpleExpr::ConstMallocAccess { .. } => {}
     }
 }
 
@@ -338,7 +391,7 @@ fn check_boolean_scoping(boolean: &Boolean, ctx: &Context) {
         Boolean::Equal { left, right } | Boolean::Different { left, right } => {
             check_expr_scoping(left, ctx);
             check_expr_scoping(right, ctx);
-        },
+        }
     }
 }
 
@@ -346,7 +399,7 @@ fn check_condition_scoping(condition: &Condition, ctx: &Context) {
     match condition {
         Condition::Expression(expr, _) => {
             check_expr_scoping(expr, ctx);
-        },
+        }
         Condition::Comparison(boolean) => {
             check_boolean_scoping(boolean, ctx);
         }
@@ -398,7 +451,7 @@ fn simplify_lines(
         match line {
             Line::ForwardDeclaration { var } => {
                 res.push(SimpleLine::ForwardDeclaration { var: var.clone() });
-            },
+            }
             Line::Match { value, arms } => {
                 let simple_value = simplify_expr(value, &mut res, counters, array_manager, const_malloc);
                 let mut simple_arms = vec![];
@@ -931,7 +984,7 @@ pub fn find_variable_usage(lines: &[Line]) -> (BTreeSet<Var>, BTreeSet<Var>) {
         match line {
             Line::ForwardDeclaration { var } => {
                 internal_vars.insert(var.clone());
-            },
+            }
             Line::Match { value, arms } => {
                 on_new_expr(value, &internal_vars, &mut external_vars);
                 for (_, statements) in arms {
@@ -1596,7 +1649,7 @@ fn handle_inlined_functions_helper(
                     let mut inlined_lines = vec![];
 
                     for var in return_data.iter() {
-                        inlined_lines.push(Line::ForwardDeclaration { var : var.clone() });
+                        inlined_lines.push(Line::ForwardDeclaration { var: var.clone() });
                     }
 
                     let mut simplified_args = vec![];
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index a1ebefe0..04a1d145 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -28,7 +28,7 @@ struct StackFrameLayout {
 
 #[derive(Default)]
 struct ScopeLayout {
-    var_positions: BTreeMap<Var, usize>, // var -> memory offset from fp
+    var_positions: BTreeMap<Var, usize>,              // var -> memory offset from fp
     const_mallocs: BTreeMap<ConstMallocLabel, usize>, // const_malloc_label -> start = memory offset from fp
 }
 
@@ -95,7 +95,7 @@ impl IntermediateValue {
             SimpleExpr::ConstMallocAccess { malloc_label, offset } => Self::MemoryAfterFp {
                 offset: compiler.get_offset(&VarOrConstMallocAccess::ConstMallocAccess {
                     malloc_label: *malloc_label,
-                    offset: offset.clone()
+                    offset: offset.clone(),
                 }),
             },
         }
@@ -167,7 +167,9 @@ fn compile_lines(
         match line {
             SimpleLine::ForwardDeclaration { var } => {
                 let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                current_scope_layout
+                    .var_positions
+                    .insert(var.clone(), compiler.stack_pos);
                 compiler.stack_pos += 1;
             }
 
@@ -180,9 +182,13 @@ fn compile_lines(
                 let arg0 = IntermediateValue::from_simple_expr(arg0, compiler);
                 let arg1 = IntermediateValue::from_simple_expr(arg1, compiler);
 
-                if let VarOrConstMallocAccess::Var(var) = var && !compiler.is_in_scope(var) {
+                if let VarOrConstMallocAccess::Var(var) = var
+                    && !compiler.is_in_scope(var)
+                {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
 
@@ -216,12 +222,7 @@ fn compile_lines(
                 let mut new_stack_pos = saved_stack_pos;
                 for (i, arm) in arms.iter().enumerate() {
                     compiler.stack_pos = saved_stack_pos;
-                    let arm_instructions = compile_lines(
-                        function_name,
-                        arm,
-                        compiler,
-                        Some(end_label.clone()),
-                    )?;
+                    let arm_instructions = compile_lines(function_name, arm, compiler, Some(end_label.clone()))?;
                     compiled_arms.push(arm_instructions);
                     new_stack_pos = new_stack_pos.max(compiler.stack_pos);
                 }
@@ -350,21 +351,11 @@ fn compile_lines(
 
                 let saved_stack_pos = compiler.stack_pos;
 
-                let then_instructions = compile_lines(
-                    function_name,
-                    then_branch,
-                    compiler,
-                    Some(end_label.clone()),
-                )?;
+                let then_instructions = compile_lines(function_name, then_branch, compiler, Some(end_label.clone()))?;
 
                 let then_stack_pos = compiler.stack_pos;
                 compiler.stack_pos = saved_stack_pos;
-                let else_instructions = compile_lines(
-                    function_name,
-                    else_branch,
-                    compiler,
-                    Some(end_label.clone()),
-                )?;
+                let else_instructions = compile_lines(function_name, else_branch, compiler, Some(end_label.clone()))?;
 
                 compiler.bytecode.insert(if_label, then_instructions);
                 compiler.bytecode.insert(else_label, else_instructions);
@@ -381,9 +372,13 @@ fn compile_lines(
             }
 
             SimpleLine::RawAccess { res, index, shift } => {
-                if let SimpleExpr::Var(var) = res && !compiler.is_in_scope(var) {
+                if let SimpleExpr::Var(var) = res
+                    && !compiler.is_in_scope(var)
+                {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
                 let shift_0 = match index {
@@ -421,7 +416,9 @@ fn compile_lines(
                 for var in return_data.iter() {
                     if !compiler.is_in_scope(var) {
                         let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                        current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                        current_scope_layout
+                            .var_positions
+                            .insert(var.clone(), compiler.stack_pos);
                         compiler.stack_pos += 1;
                     }
                 }
@@ -440,12 +437,7 @@ fn compile_lines(
                         });
                     }
 
-                    instructions.extend(compile_lines(
-                        function_name,
-                        &lines[i + 1..],
-                        compiler,
-                        final_jump,
-                    )?);
+                    instructions.extend(compile_lines(function_name, &lines[i + 1..], compiler, final_jump)?);
 
                     instructions
                 };
@@ -502,7 +494,9 @@ fn compile_lines(
             } => {
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
                 instructions.push(IntermediateInstruction::RequestMemory {
@@ -516,7 +510,9 @@ fn compile_lines(
                 let size = size.naive_eval().unwrap().to_usize(); // TODO not very good;
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
                 handle_const_malloc(&mut instructions, compiler, var, size, label);
@@ -528,7 +524,9 @@ fn compile_lines(
             } => {
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
 
@@ -540,13 +538,7 @@ fn compile_lines(
                         .collect(),
                 });
 
-                handle_const_malloc(
-                    &mut instructions,
-                    compiler,
-                    var,
-                    F::bits() * to_decompose.len(),
-                    label,
-                );
+                handle_const_malloc(&mut instructions, compiler, var, F::bits() * to_decompose.len(), label);
             }
             SimpleLine::DecomposeCustom {
                 var,
@@ -555,7 +547,9 @@ fn compile_lines(
             } => {
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
 
@@ -567,18 +561,14 @@ fn compile_lines(
                         .collect(),
                 });
 
-                handle_const_malloc(
-                    &mut instructions,
-                    compiler,
-                    var,
-                    F::bits() * to_decompose.len(),
-                    label,
-                );
+                handle_const_malloc(&mut instructions, compiler, var, F::bits() * to_decompose.len(), label);
             }
             SimpleLine::CounterHint { var } => {
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
-                    current_scope_layout.var_positions.insert(var.clone(), compiler.stack_pos);
+                    current_scope_layout
+                        .var_positions
+                        .insert(var.clone(), compiler.stack_pos);
                     compiler.stack_pos += 1;
                 }
                 instructions.push(IntermediateInstruction::CounterHint {
diff --git a/crates/lean_compiler/src/lang.rs b/crates/lean_compiler/src/lang.rs
index 345b8628..18df575f 100644
--- a/crates/lean_compiler/src/lang.rs
+++ b/crates/lean_compiler/src/lang.rs
@@ -307,7 +307,9 @@ pub enum Line {
         value: Expression,
         arms: Vec<(usize, Vec<Self>)>,
     },
-    ForwardDeclaration { var: Var },
+    ForwardDeclaration {
+        var: Var,
+    },
     Assignment {
         var: Var,
         value: Expression,
diff --git a/crates/lean_compiler/tests/test_compiler.rs b/crates/lean_compiler/tests/test_compiler.rs
index e49a6a4a..18f004da 100644
--- a/crates/lean_compiler/tests/test_compiler.rs
+++ b/crates/lean_compiler/tests/test_compiler.rs
@@ -399,7 +399,6 @@ fn test_inlined_2() {
     }
    "#;
     compile_and_run(program.to_string(), (&[], &[]), DEFAULT_NO_VEC_RUNTIME_MEMORY, false);
-
 }
 
 #[test]
diff --git a/crates/lean_vm/src/execution/memory.rs b/crates/lean_vm/src/execution/memory.rs
index 00a685d9..7ece75cd 100644
--- a/crates/lean_vm/src/execution/memory.rs
+++ b/crates/lean_vm/src/execution/memory.rs
@@ -25,7 +25,11 @@ impl Memory {
     ///
     /// Returns an error if the address is uninitialized
     pub fn get(&self, index: usize) -> Result<F, RunnerError> {
-        self.0.get(index).copied().flatten().ok_or(RunnerError::UndefinedMemory(index))
+        self.0
+            .get(index)
+            .copied()
+            .flatten()
+            .ok_or(RunnerError::UndefinedMemory(index))
     }
 
     /// Sets a value at a memory address
diff --git a/crates/lean_vm/src/execution/runner.rs b/crates/lean_vm/src/execution/runner.rs
index 381a9310..78f72ced 100644
--- a/crates/lean_vm/src/execution/runner.rs
+++ b/crates/lean_vm/src/execution/runner.rs
@@ -245,7 +245,9 @@ fn execute_bytecode_helper(
             n_poseidon16_precomputed_used: &mut n_poseidon16_precomputed_used,
             n_poseidon24_precomputed_used: &mut n_poseidon24_precomputed_used,
         };
-        instruction.execute_instruction(&mut instruction_ctx).map_err(|e| (pc, e))?;
+        instruction
+            .execute_instruction(&mut instruction_ctx)
+            .map_err(|e| (pc, e))?;
     }
 
     assert_eq!(
diff --git a/crates/lean_vm/src/execution/tests.rs b/crates/lean_vm/src/execution/tests.rs
index 92c16fd6..3c20aa46 100644
--- a/crates/lean_vm/src/execution/tests.rs
+++ b/crates/lean_vm/src/execution/tests.rs
@@ -25,7 +25,14 @@ fn test_memory_already_set_error() {
     memory.set(0, F::ONE).unwrap();
 
     // Setting different value should fail
-    assert!(matches!(memory.set(0, F::ZERO), Err(RunnerError::MemoryAlreadySet { address: 0, prev_value: F::ONE, new_value: F::ZERO })));
+    assert!(matches!(
+        memory.set(0, F::ZERO),
+        Err(RunnerError::MemoryAlreadySet {
+            address: 0,
+            prev_value: F::ONE,
+            new_value: F::ZERO
+        })
+    ));
 }
 
 #[test]

From 6ced2cd22792ba549dc89fdbce4d171fea069c82 Mon Sep 17 00:00:00 2001
From: Morgan Thomas <morgan.a.s.thomas@gmail.com>
Date: Tue, 9 Dec 2025 02:18:04 +0000
Subject: [PATCH 20/20] clippy

---
 crates/lean_compiler/src/a_simplify_lang.rs   | 30 ++++++++-----------
 .../src/b_compile_intermediate.rs             |  7 ++---
 crates/lean_compiler/src/lib.rs               | 11 +++----
 crates/lean_prover/tests/test_zkvm.rs         |  2 +-
 4 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/crates/lean_compiler/src/a_simplify_lang.rs b/crates/lean_compiler/src/a_simplify_lang.rs
index 680aa860..51b4c0e9 100644
--- a/crates/lean_compiler/src/a_simplify_lang.rs
+++ b/crates/lean_compiler/src/a_simplify_lang.rs
@@ -207,15 +207,14 @@ fn check_program_scoping(program: &Program) {
 }
 
 /// Analyzes the block to verify that each variable is defined in each context where it is used.
-fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
+fn check_block_scoping(block: &[Line], ctx: &mut Context) {
     for line in block.iter() {
         match line {
             Line::ForwardDeclaration { var } => {
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
-                    "Variable declared multiple times in the same scope: {:?}",
-                    var
+                    "Variable declared multiple times in the same scope: {var}",
                 );
                 last_scope.vars.insert(var.clone());
             }
@@ -232,8 +231,7 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
-                    "Variable declared multiple times in the same scope: {:?}",
-                    var
+                    "Variable declared multiple times in the same scope: {var}",
                 );
                 last_scope.vars.insert(var.clone());
             }
@@ -288,8 +286,7 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 for var in return_data {
                     assert!(
                         !last_scope.vars.contains(var),
-                        "Variable declared multiple times in the same scope: {:?}",
-                        var
+                        "Variable declared multiple times in the same scope: {var}",
                     );
                     last_scope.vars.insert(var.clone());
                 }
@@ -321,8 +318,7 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
-                    "Variable declared multiple times in the same scope: {:?}",
-                    var
+                    "Variable declared multiple times in the same scope: {var}",
                 );
                 last_scope.vars.insert(var.clone());
             }
@@ -333,8 +329,7 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
-                    "Variable declared multiple times in the same scope: {:?}",
-                    var
+                    "Variable declared multiple times in the same scope: {var}",
                 );
                 last_scope.vars.insert(var.clone());
             }
@@ -342,8 +337,7 @@ fn check_block_scoping(block: &Vec<Line>, ctx: &mut Context) {
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
-                    "Variable declared multiple times in the same scope: {:?}",
-                    var
+                    "Variable declared multiple times in the same scope: {var}",
                 );
                 last_scope.vars.insert(var.clone());
             }
@@ -359,18 +353,18 @@ fn check_expr_scoping(expr: &Expression, ctx: &Context) {
         }
         Expression::ArrayAccess { array, index } => {
             check_simple_expr_scoping(array, ctx);
-            check_expr_scoping(&*index, ctx);
+            check_expr_scoping(index, ctx);
         }
         Expression::Binary {
             left,
             operation: _,
             right,
         } => {
-            check_expr_scoping(&*left, ctx);
-            check_expr_scoping(&*right, ctx);
+            check_expr_scoping(left, ctx);
+            check_expr_scoping(right, ctx);
         }
         Expression::Log2Ceil { value } => {
-            check_expr_scoping(&*value, ctx);
+            check_expr_scoping(value, ctx);
         }
     }
 }
@@ -379,7 +373,7 @@ fn check_expr_scoping(expr: &Expression, ctx: &Context) {
 fn check_simple_expr_scoping(expr: &SimpleExpr, ctx: &Context) {
     match expr {
         SimpleExpr::Var(v) => {
-            assert!(ctx.defines(&v), "Variable used but not defined: {:?}", v)
+            assert!(ctx.defines(v), "Variable used but not defined: {v}a)");
         }
         SimpleExpr::Constant(_) => {}
         SimpleExpr::ConstMallocAccess { .. } => {}
diff --git a/crates/lean_compiler/src/b_compile_intermediate.rs b/crates/lean_compiler/src/b_compile_intermediate.rs
index 04a1d145..c8b0063e 100644
--- a/crates/lean_compiler/src/b_compile_intermediate.rs
+++ b/crates/lean_compiler/src/b_compile_intermediate.rs
@@ -1,10 +1,7 @@
 use crate::{F, a_simplify_lang::*, ir::*, lang::*};
 use lean_vm::*;
 use multilinear_toolkit::prelude::*;
-use std::{
-    borrow::Borrow,
-    collections::{BTreeMap, BTreeSet},
-};
+use std::collections::{BTreeMap, BTreeSet};
 use utils::ToUsize;
 
 #[derive(Default)]
@@ -220,7 +217,7 @@ fn compile_lines(
                 let mut compiled_arms = vec![];
                 let saved_stack_pos = compiler.stack_pos;
                 let mut new_stack_pos = saved_stack_pos;
-                for (i, arm) in arms.iter().enumerate() {
+                for arm in arms.iter() {
                     compiler.stack_pos = saved_stack_pos;
                     let arm_instructions = compile_lines(function_name, arm, compiler, Some(end_label.clone()))?;
                     compiled_arms.push(arm_instructions);
diff --git a/crates/lean_compiler/src/lib.rs b/crates/lean_compiler/src/lib.rs
index 3b8cbdf2..1c326cdd 100644
--- a/crates/lean_compiler/src/lib.rs
+++ b/crates/lean_compiler/src/lib.rs
@@ -16,17 +16,18 @@ pub fn compile_program(program: String) -> Bytecode {
     let (parsed_program, function_locations) = parse_program(&program).unwrap();
     // println!("Parsed program: {}", parsed_program.to_string());
     let simple_program = simplify_program(parsed_program);
-    println!("Simplified program: {}", simple_program.to_string());
+    // println!("Simplified program: {}", simple_program);
     let intermediate_bytecode = compile_to_intermediate_bytecode(simple_program).unwrap();
-    println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
+    // println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
 
     // println!("Function Locations: \n");
     // for (loc, name) in function_locations.iter() {
     //     println!("{name}: {loc}");
     // }
-    let compiled = compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap();
-    println!("\n\nCompiled Program:\n\n{compiled}");
-    compiled
+    /* let compiled = */
+    compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap() //;
+    // println!("\n\nCompiled Program:\n\n{compiled}");
+    // compiled
 }
 
 pub fn compile_and_run(
diff --git a/crates/lean_prover/tests/test_zkvm.rs b/crates/lean_prover/tests/test_zkvm.rs
index 8ee67ecd..195dd570 100644
--- a/crates/lean_prover/tests/test_zkvm.rs
+++ b/crates/lean_prover/tests/test_zkvm.rs
@@ -125,6 +125,6 @@ fn test_zk_vm_helper(program_str: &str, (public_input, private_input): (&[F], &[
     );
     let proof_time = time.elapsed();
     verify_execution(&bytecode, public_input, proof_data, whir_config_builder()).unwrap();
-    println!("{}", summary);
+    println!("{summary}");
     println!("Proof time: {:.3} s", proof_time.as_secs_f32());
 }