Remove todo by going with new approach to Rc

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

@@ -462,6 +462,11 @@ impl FunctionBuilder {
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
     pub(crate) fn increment_array_reference_count(&mut self, value: ValueId) {
+        // Reference-counted arrays are only needed for Brillig's copy on write optimization.
+        if self.current_function.runtime() != RuntimeType::Brillig {
+            return;
+        }
+
         match self.type_of_value(value) {
             Type::Numeric(_) => (),
             Type::Function => (),
@@ -471,26 +476,10 @@ impl FunctionBuilder {
                     self.increment_array_reference_count(value);
                 }
             }
-            Type::Array(element_types, length) => {
-                self.insert_instruction(Instruction::IncrementRc { value }, None);
-
-                if element_types.iter().any(|element| element.contains_an_array()) {
-                    for i in 0..length {
-                        let index = self.field_constant(i as u128);
-                        let element_type = element_types[i % element_types.len()].clone();
-                        let element = self.insert_array_get(value, index, element_type);
-                        self.increment_array_reference_count(element);
-                    }
-                }
-            }
-            Type::Slice(element_types) => {
+            Type::Array(..) | Type::Slice(..) => {
                 self.insert_instruction(Instruction::IncrementRc { value }, None);
-
-                for element_type in element_types.iter() {
-                    if element_type.contains_an_array() {
-                        todo!("inc_rc for nested slices")
-                    }
-                }
+                // If there are nested arrays or slices, we wait until ArrayGet
+                // is issued to increment the count of that array.
             }
         }
     }

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

@@ -210,6 +210,13 @@ impl<'a> FunctionContext<'a> {
         for element in elements {
             element.for_each(|element| {
                 let element = element.eval(self);
+
+                // If we're referencing a sub-array in a larger nested array we need to
+                // increase the reference count of the sub array. This maintains a
+                // pessimistic reference count (since some are likely moved rather than shared)
+                // which is important for Brillig's copy on write optimization. This has no
+                // effect in ACIR code.
+                self.builder.increment_array_reference_count(element);
                 array.push_back(element);
             });
         }
@@ -301,6 +308,7 @@ impl<'a> FunctionContext<'a> {
         } else {
             (array_or_slice[0], None)
         };
+
         self.codegen_array_index(
             array,
             index_value,
@@ -345,7 +353,13 @@ impl<'a> FunctionContext<'a> {
                 }
                 _ => unreachable!("must have array or slice but got {array_type}"),
             }
-            self.builder.insert_array_get(array, offset, typ).into()
+
+            // Reference counting in brillig relies on us incrementing reference
+            // counts when nested arrays/slices are constructed or indexed. This
+            // has not effect in ACIR code.
+            let result = self.builder.insert_array_get(array, offset, typ);
+            self.builder.increment_array_reference_count(result);
+            result.into()
         }))
     }