fix(ssa_gen): Generate code for index before the collection

compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs

@@ -424,8 +424,10 @@ impl FunctionContext<'_> {
     }
 
     fn codegen_index(&mut self, index: &ast::Index) -> Result<Values, RuntimeError> {
-        let array_or_slice = self.codegen_expression(&index.collection)?.into_value_list(self);
+        // Generate the index value first, it might modify the collection itself.
         let index_value = self.codegen_non_tuple_expression(&index.index)?;
+        // The code for the collection will load it if it's mutable. It must be after the index to see any modifications.
+        let array_or_slice = self.codegen_expression(&index.collection)?.into_value_list(self);
         // Slices are represented as a tuple in the form: (length, slice contents).
         // Thus, slices require two value ids for their representation.
         let (array, slice_length) = if array_or_slice.len() > 1 {

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

@@ -929,13 +929,13 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
     }
 
     fn evaluate_index(&mut self, index: HirIndexExpression, id: ExprId) -> IResult<Value> {
+        let idx = self.evaluate(index.index)?;
         let array = self.evaluate(index.collection)?;
-        let index = self.evaluate(index.index)?;
 
         let location = self.elaborator.interner.expr_location(&id);
-        let (array, index) = bounds_check(array, index, location)?;
+        let (array, idx) = bounds_check(array, idx, location)?;
 
-        Ok(array[index].clone())
+        Ok(array[idx].clone())
     }
 
     fn evaluate_constructor(

test_programs/execution_success/regression_9329/Nargo.toml

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

test_programs/execution_success/regression_9329/Prover.toml

@@ -0,0 +1,3 @@
+
+b = [10, 20]
+return = 21

test_programs/execution_success/regression_9329/src/main.nr

@@ -0,0 +1,16 @@
+fn main(b: [i8; 2]) -> pub i8 {
+    let i = foo(b);
+    let c = comptime { foo([10, 20]) };
+    assert_eq(i, c);
+    i
+}
+
+fn foo(mut b: [i8; 2]) -> i8 {
+    b[{
+        let d = 1;
+        for _ in 0..2 {
+            b[0] = b[1] + d;
+        }
+        0
+    }]
+}