Try remove mutated arrays field

compiler/noirc_evaluator/src/ssa/opt/die.rs

@@ -141,7 +141,6 @@ 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,
@@ -533,10 +532,11 @@ struct RcTracker {
     // If we see an inc/dec RC pair within a block we can safely remove both instructions.
     rcs_with_possible_pairs: HashMap<Type, Vec<RcInstruction>>,
     rc_pairs_to_remove: HashSet<InstructionId>,
+
     // 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>>,
-    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.
@@ -589,38 +589,10 @@ impl RcTracker {
                         dec_rc.possibly_mutated = true;
                     }
                 }
-
-                self.mutated_array_types.insert(typ);
-            }
-            Instruction::Store { value, .. } => {
-                // We are very conservative and say that any store of an array value means that any
-                // array of that type has the potential to be mutated. This is done due to the
-                // tracking of mutable borrows still being per block and that we don't have the
-                // aliasing information from mem2reg.
-                let typ = function.dfg.type_of_value(*value);
-                if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
-                    self.mutated_array_types.insert(typ);
-                }
             }
             _ => {}
         }
     }
-
-    fn get_non_mutated_arrays(&self, dfg: &DataFlowGraph) -> HashSet<InstructionId> {
-        self.inc_rcs
-            .keys()
-            .filter_map(|value| {
-                let typ = dfg.type_of_value(*value);
-                if !self.mutated_array_types.contains(&typ) {
-                    Some(&self.inc_rcs[value])
-                } else {
-                    None
-                }
-            })
-            .flatten()
-            .copied()
-            .collect()
-    }
 }
 #[cfg(test)]
 mod test {