revert #5547

noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs

@@ -1,11 +1,9 @@
 use iter_extended::vecmap;
 
-use crate::ssa::ir::types::Type;
-
 use super::{
     basic_block::BasicBlockId,
     dfg::{CallStack, InsertInstructionResult},
-    function::{Function, RuntimeType},
+    function::Function,
     instruction::{Instruction, InstructionId},
     value::ValueId,
 };
@@ -22,7 +20,7 @@ pub(crate) struct FunctionInserter<'f> {
     /// array unnecessarily. An extra bool is included as part of the key to
     /// distinguish between Type::Array and Type::Slice, as both are valid
     /// types for a Value::Array
-    const_arrays: HashMap<(im::Vector<ValueId>, bool), ValueId>,
+    const_arrays: HashMap<im::Vector<ValueId>, ValueId>,
 }
 
 impl<'f> FunctionInserter<'f> {
@@ -44,26 +42,15 @@ impl<'f> FunctionInserter<'f> {
                     let new_array: im::Vector<ValueId> =
                         array.iter().map(|id| self.resolve(*id)).collect();
 
-                    // Flag to determine the type of the value's array list
-                    let is_array = matches!(typ, Type::Array { .. });
-                    if let Some(fetched_value) =
-                        self.const_arrays.get(&(new_array.clone(), is_array))
-                    {
-                        // Arrays in ACIR are immutable, but in Brillig arrays are copy-on-write
-                        // so for function's with a Brillig runtime we make sure to check that value
-                        // in our constants array map matches the resolved array value id.
-                        if matches!(self.function.runtime(), RuntimeType::Acir(_)) {
-                            return *fetched_value;
-                        } else if *fetched_value == value {
-                            return value;
-                        }
-                    };
-
-                    let new_array_clone = new_array.clone();
-                    let new_id = self.function.dfg.make_array(new_array, typ);
-                    self.values.insert(value, new_id);
-                    self.const_arrays.insert((new_array_clone, is_array), new_id);
-                    new_id
+                    if self.const_arrays.get(&new_array) == Some(&value) {
+                        value
+                    } else {
+                        let new_array_clone = new_array.clone();
+                        let new_id = self.function.dfg.make_array(new_array, typ);
+                        self.values.insert(value, new_id);
+                        self.const_arrays.insert(new_array_clone, new_id);
+                        new_id
+                    }
                 }
                 _ => value,
             },
@@ -127,6 +114,7 @@ impl<'f> FunctionInserter<'f> {
         block: BasicBlockId,
         call_stack: CallStack,
     ) -> InsertInstructionResult {
+        let toto = self.function.name().clone().to_string();
         let results = self.function.dfg.instruction_results(id);
         let results = vecmap(results, |id| self.function.dfg.resolve(*id));
 
@@ -139,6 +127,7 @@ impl<'f> FunctionInserter<'f> {
             block,
             ctrl_typevars,
             call_stack,
+            &toto,
         );
 
         Self::insert_new_instruction_results(&mut self.values, &results, &new_results);