feat: Don't increment parameter ref counts at all

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

@@ -442,37 +442,44 @@ 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) {
-        self.update_array_reference_count(value, true);
+        self.update_array_reference_count(value, true, true);
     }
 
     /// Insert instructions to decrement the reference count of any array(s) stored
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
     pub(crate) fn decrement_array_reference_count(&mut self, value: ValueId) {
-        self.update_array_reference_count(value, false);
+        self.update_array_reference_count(value, false, true);
     }
 
     /// Increment or decrement the given value's reference count if it is an array.
     /// If it is not an array, this does nothing. Note that inc_rc and dec_rc instructions
     /// are ignored outside of unconstrained code.
-    fn update_array_reference_count(&mut self, value: ValueId, increment: bool) {
+    pub(crate) fn update_array_reference_count(
+        &mut self,
+        value: ValueId,
+        increment: bool,
+        found_ref: bool,
+    ) {
         match self.type_of_value(value) {
             Type::Numeric(_) => (),
             Type::Function => (),
             Type::Reference(element) => {
                 if element.contains_an_array() {
                     let reference = value;
                     let value = self.insert_load(reference, element.as_ref().clone());
-                    self.update_array_reference_count(value, increment);
+                    self.update_array_reference_count(value, increment, true);
                 }
             }
             Type::Array(..) | Type::Slice(..) => {
                 // If there are nested arrays or slices, we wait until ArrayGet
                 // is issued to increment the count of that array.
-                if increment {
-                    self.insert_inc_rc(value);
-                } else {
-                    self.insert_dec_rc(value);
+                if found_ref {
+                    if increment {
+                        self.insert_inc_rc(value);
+                    } else {
+                        self.insert_dec_rc(value);
+                    }
                 }
             }
         }

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

@@ -929,7 +929,7 @@ impl<'a> FunctionContext<'a> {
     /// This will issue DecrementRc instructions for any arrays in the given starting scope
     /// block's parameters. Arrays that are also used in terminator instructions for the scope are
     /// ignored.
-    pub(crate) fn end_scope(&mut self, scope: BasicBlockId, terminator_args: &[ValueId]) {
+    pub(crate) fn end_function(&mut self, scope: BasicBlockId, terminator_args: &[ValueId]) {
         let mut dropped_parameters =
             self.builder.current_function.dfg.block_parameters(scope).to_vec();
 

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

@@ -125,10 +125,10 @@ impl<'a> FunctionContext<'a> {
     /// Codegen a function's body and set its return value to that of its last parameter.
     /// For functions returning nothing, this will be an empty list.
     fn codegen_function_body(&mut self, body: &Expression) -> Result<(), RuntimeError> {
-        let entry_block = self.increment_parameter_rcs();
+        // let entry_block = self.builder.current_function.entry_block(); // self.increment_parameter_rcs();
         let return_value = self.codegen_expression(body)?;
         let results = return_value.into_value_list(self);
-        self.end_scope(entry_block, &results);
+        // self.end_function(entry_block, &results);
 
         self.builder.terminate_with_return(results);
         Ok(())