Apply fix from #2466

crates/noirc_evaluator/src/ssa.rs

@@ -63,6 +63,7 @@ pub(crate) fn optimize_into_acir(
             // and this pass is missed, slice merging will fail inside of flattening.
             .mem2reg()
             .print(print_ssa_passes, "After Mem2Reg:")
+            .fold_constants()
             .flatten_cfg()
             .print(print_ssa_passes, "After Flattening:")
             // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores

crates/noirc_evaluator/src/ssa/opt/constant_folding.rs

@@ -102,7 +102,9 @@ impl Context {
 
         // If the instruction doesn't have side-effects, cache the results so we can reuse them if
         // the same instruction appears again later in the block.
-        if !instruction.has_side_effects(&function.dfg) {
+        if !instruction.has_side_effects(&function.dfg)
+            && !matches!(instruction, Instruction::Allocate)
+        {
             instruction_result_cache.insert(instruction, new_results.clone());
         }
         for (old_result, new_result) in old_results.iter().zip(new_results) {

crates/noirc_evaluator/src/ssa/opt/mem2reg.rs

@@ -372,12 +372,7 @@ impl PerFunctionContext {
         }
     }
 
-    fn mark_all_unknown(
-        &self,
-        values: &[ValueId],
-        function: &Function,
-        references: &mut Block,
-    ) {
+    fn mark_all_unknown(&self, values: &[ValueId], function: &Function, references: &mut Block) {
         for value in values {
             if function.dfg.value_is_reference(*value) {
                 let value = function.dfg.resolve(*value);
@@ -455,26 +450,15 @@ impl Block {
     }
 
     /// If the given address is known, set its value to `ReferenceValue::Known(value)`.
-    fn set_known_value(
-        &mut self,
-        address: ValueId,
-        value: ValueId,
-    ) {
+    fn set_known_value(&mut self, address: ValueId, value: ValueId) {
         self.set_value(address, ReferenceValue::Known(value));
     }
 
-    fn set_unknown(
-        &mut self,
-        address: ValueId,
-    ) {
+    fn set_unknown(&mut self, address: ValueId) {
         self.set_value(address, ReferenceValue::Unknown);
     }
 
-    fn set_value(
-        &mut self,
-        address: ValueId,
-        value: ReferenceValue,
-    ) {
+    fn set_value(&mut self, address: ValueId, value: ReferenceValue) {
         let expression = self.expressions.entry(address).or_insert(Expression::Other(address));
         let aliases = self.aliases.entry(expression.clone()).or_default();
 
@@ -555,7 +539,11 @@ impl Block {
     }
 
     /// Iterate through each known alias of the given address and apply the function `f` to each.
-    fn for_each_alias_of<T>(&mut self, address: ValueId, mut f: impl FnMut(&mut Self, ValueId) -> T) {
+    fn for_each_alias_of<T>(
+        &mut self,
+        address: ValueId,
+        mut f: impl FnMut(&mut Self, ValueId) -> T,
+    ) {
         if let Some(expr) = self.expressions.get(&address) {
             if let Some(aliases) = self.aliases.get(expr).cloned() {
                 for alias in aliases {
@@ -565,11 +553,7 @@ impl Block {
         }
     }
 
-    fn keep_last_stores_for(
-        &mut self,
-        address: ValueId,
-        function: &Function,
-    ) {
+    fn keep_last_stores_for(&mut self, address: ValueId, function: &Function) {
         let address = function.dfg.resolve(address);
         self.keep_last_store(address, function);
         self.for_each_alias_of(address, |t, alias| t.keep_last_store(alias, function));
@@ -584,17 +568,15 @@ impl Block {
             match &function.dfg[instruction] {
                 Instruction::Store { value, .. } => {
                     self.mark_value_used(*value, function);
-                },
-                other => unreachable!("last_store held an id of a non-store instruction: {other:?}"),
+                }
+                other => {
+                    unreachable!("last_store held an id of a non-store instruction: {other:?}")
+                }
             }
         }
     }
 
-    fn mark_value_used(
-        &mut self,
-        value: ValueId,
-        function: &Function,
-    ) {
+    fn mark_value_used(&mut self, value: ValueId, function: &Function) {
         self.keep_last_stores_for(value, function);
 
         // We must do a recursive check for arrays since they're the only Values which may contain