From 8f7bbb1ffa6f8b41524094b4e508723f616d07dc Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 12 Dec 2024 04:06:31 +0000
Subject: [PATCH 1/2] check non mutated arrays but by type

---
 compiler/noirc_evaluator/src/ssa/opt/die.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index 148c9eafa23..609dbb13dec 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -139,6 +139,7 @@ impl Context {
             rc_tracker.track_inc_rcs_to_remove(*instruction_id, function);
         }
 
+        self.instructions_to_remove.extend(rc_tracker.get_non_mutated_arrays(&function.dfg));
         self.instructions_to_remove.extend(rc_tracker.rc_pairs_to_remove);
 
         // If there are some instructions that might trigger an out of bounds error,
@@ -539,7 +540,7 @@ struct RcTracker {
     // We also separately track all IncrementRc instructions and all arrays which have been mutably borrowed.
     // If an array has not been mutably borrowed we can then safely remove all IncrementRc instructions on that array.
     inc_rcs: HashMap<ValueId, HashSet<InstructionId>>,
-    mut_borrowed_arrays: HashSet<ValueId>,
+    mutated_array_types: HashSet<Type>,
     // The SSA often creates patterns where after simplifications we end up with repeat
     // IncrementRc instructions on the same value. We track whether the previous instruction was an IncrementRc,
     // and if the current instruction is also an IncrementRc on the same value we remove the current instruction.
@@ -593,25 +594,25 @@ impl RcTracker {
                     }
                 }
 
-                self.mut_borrowed_arrays.insert(*array);
+                self.mutated_array_types.insert(typ);
             }
             Instruction::Store { value, .. } => {
-                // We are very conservative and say that any store of an array value means it has the potential
-                // to be mutated. This is done due to the tracking of mutable borrows still being per block.
+                // We are very conservative and say that any store of an array type means it has the potential to be mutated.
                 let typ = function.dfg.type_of_value(*value);
                 if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
-                    self.mut_borrowed_arrays.insert(*value);
+                    self.mutated_array_types.insert(typ);
                 }
             }
             _ => {}
         }
     }
 
-    fn get_non_mutated_arrays(&self) -> HashSet<InstructionId> {
+    fn get_non_mutated_arrays(&self, dfg: &DataFlowGraph) -> HashSet<InstructionId> {
         self.inc_rcs
             .keys()
             .filter_map(|value| {
-                if !self.mut_borrowed_arrays.contains(value) {
+                let typ = dfg.type_of_value(*value);
+                if !self.mutated_array_types.contains(&typ) {
                     Some(&self.inc_rcs[value])
                 } else {
                     None

From 3f962d1e1fa1a06e825a782710e290c7db9a8d39 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 12 Dec 2024 04:20:52 +0000
Subject: [PATCH 2/2] add call args to rc tracker

---
 compiler/noirc_evaluator/src/ssa/opt/die.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index 609dbb13dec..5a0a6585697 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -603,6 +603,14 @@ impl RcTracker {
                     self.mutated_array_types.insert(typ);
                 }
             }
+            Instruction::Call { arguments, .. } => {
+                for arg in arguments {
+                    let typ = function.dfg.type_of_value(*arg);
+                    if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
+                        self.mutated_array_types.insert(typ);
+                    }
+                }
+            }
             _ => {}
         }
     }