fix: Fix brillig slowdown when assigning arrays in loops

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

@@ -393,10 +393,25 @@ impl FunctionBuilder {
                     self.increment_array_reference_count(value);
                 }
             }
-            Type::Array(..) | Type::Slice(..) => {
-                self.insert_instruction(Instruction::IncrementRc { value }, None);
+            typ @ Type::Array(..) | typ @ Type::Slice(..) => {
                 // If there are nested arrays or slices, we wait until ArrayGet
                 // is issued to increment the count of that array.
+                self.insert_instruction(Instruction::IncrementRc { value }, None);
+
+                // This is a bit odd, but in brillig the inc_rc instruction operates on
+                // a copy of the array's metadata, so we need to re-store a loaded array
+                // even if there have been no other changes to it.
+                if let Value::Instruction { instruction, .. } = &self.current_function.dfg[value] {
+                    let instruction = &self.current_function.dfg[*instruction];
+                    if let Instruction::Load { address } = instruction {
+                        // We can't re-use `value` in case the original address was stored
+                        // to again in the meantime. So introduce another load.
+                        let address = *address;
+                        let value = self.insert_load(address, typ);
+                        self.insert_instruction(Instruction::IncrementRc { value }, None);
+                        self.insert_store(address, value);
+                    }
+                }
             }
         }
     }

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

@@ -722,6 +722,11 @@ impl<'a> FunctionContext<'a> {
         let lhs = self.extract_current_value(&assign.lvalue)?;
         let rhs = self.codegen_expression(&assign.expression)?;
 
+        rhs.clone().for_each(|value| {
+            let value = value.eval(self);
+            self.builder.increment_array_reference_count(value);
+        });
+
         self.assign_new_value(lhs, rhs);
         Ok(Self::unit_value())
     }

test_programs/execution_success/brillig_cow_assign/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "brillig_cow_assign"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]

test_programs/execution_success/brillig_cow_assign/Prover.toml

@@ -0,0 +1,2 @@
+items_to_update = 10
+index = 6

test_programs/execution_success/brillig_cow_assign/src/main.nr

@@ -0,0 +1,23 @@
+global N = 10;
+
+unconstrained fn main() {
+    let mut arr = [0; N];
+    let mut mid_change = arr;
+
+    for i in 0..N {
+        if i == N / 2 {
+            mid_change = arr;
+        }
+        arr[i] = 27;
+    }
+
+    // Expect:
+    // arr        = [27, 27, 27, 27, 27, 27, 27, 27, 27, 27]
+    // mid_change = [27, 27, 27, 27, 27, 0, 0, 0, 0, 0]
+
+    let modified_i = N / 2 + 1;
+    assert_eq(arr[modified_i], 27);
+
+    // Fail here!
+    assert(mid_change[modified_i] != 27);
+}