diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index 78b857e9fd5..783f6d3f4b0 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -386,11 +386,11 @@ impl<'f> PerFunctionContext<'f> {
             let first = first.expect("All parameters alias at least themselves or we early return");
 
             let expression = Expression::Other(first);
-            let previous = references.aliases.insert(expression.clone(), aliases.clone());
+            let previous = references.aliases.insert(expression, aliases.clone());
             assert!(previous.is_none());
 
             aliases.for_each(|alias| {
-                let previous = references.expressions.insert(alias, expression.clone());
+                let previous = references.expressions.insert(alias, expression);
                 assert!(previous.is_none());
             });
         }
@@ -534,7 +534,7 @@ impl<'f> PerFunctionContext<'f> {
                     });
                     references.mark_value_used(array, self.inserter.function);
 
-                    let expression = Expression::ArrayElement(Box::new(Expression::Other(array)));
+                    let expression = Expression::ArrayElement(array);
 
                     if let Some(aliases) = references.aliases.get_mut(&expression) {
                         aliases.insert(result);
@@ -549,7 +549,7 @@ impl<'f> PerFunctionContext<'f> {
                     let result = self.inserter.function.dfg.instruction_results(instruction)[0];
                     let array = *array;
 
-                    let expression = Expression::ArrayElement(Box::new(Expression::Other(array)));
+                    let expression = Expression::ArrayElement(array);
 
                     let mut aliases = if let Some(aliases) = references.aliases.get_mut(&expression)
                     {
@@ -566,7 +566,7 @@ impl<'f> PerFunctionContext<'f> {
 
                     aliases.unify(&references.get_aliases_for_value(*value));
 
-                    references.expressions.insert(result, expression.clone());
+                    references.expressions.insert(result, expression);
                     references.aliases.insert(expression, aliases);
 
                     // Similar to how we remember that we used a value in a `Store` instruction,
@@ -593,8 +593,8 @@ impl<'f> PerFunctionContext<'f> {
                 if Self::contains_references(typ) {
                     let array = self.inserter.function.dfg.instruction_results(instruction)[0];
 
-                    let expr = Expression::ArrayElement(Box::new(Expression::Other(array)));
-                    references.expressions.insert(array, expr.clone());
+                    let expr = Expression::ArrayElement(array);
+                    references.expressions.insert(array, expr);
                     let aliases = references.aliases.entry(expr).or_insert(AliasSet::known_empty());
 
                     self.add_array_aliases(elements, aliases);
@@ -606,7 +606,7 @@ impl<'f> PerFunctionContext<'f> {
 
                 if Self::contains_references(&result_type) {
                     let expr = Expression::Other(result);
-                    references.expressions.insert(result, expr.clone());
+                    references.expressions.insert(result, expr);
                     references.aliases.insert(
                         expr,
                         AliasSet::known_multiple(vec![*then_value, *else_value].into()),
@@ -643,7 +643,7 @@ impl<'f> PerFunctionContext<'f> {
     fn set_aliases(&self, references: &mut Block, address: ValueId, new_aliases: AliasSet) {
         let expression =
             references.expressions.entry(address).or_insert(Expression::Other(address));
-        let aliases = references.aliases.entry(expression.clone()).or_default();
+        let aliases = references.aliases.entry(*expression).or_default();
         *aliases = new_aliases;
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
index d3ec4756f79..0c92a26d01b 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
@@ -42,10 +42,10 @@ pub(super) struct Block {
 /// An `Expression` here is used to represent a canonical key
 /// into the aliases map since otherwise two dereferences of the
 /// same address will be given different ValueIds.
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub(super) enum Expression {
-    Dereference(Box<Expression>),
-    ArrayElement(Box<Expression>),
+    Dereference(ValueId),
+    ArrayElement(ValueId),
     Other(ValueId),
 }
 
@@ -90,7 +90,7 @@ impl Block {
 
     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();
+        let aliases = self.aliases.entry(*expression).or_default();
 
         if aliases.is_unknown() {
             // uh-oh, we don't know at all what this reference refers to, could be anything.
@@ -119,7 +119,7 @@ impl Block {
             if let Some(existing) = self.expressions.get(value_id) {
                 assert_eq!(existing, expression, "Expected expressions for {value_id} to be equal");
             } else {
-                self.expressions.insert(*value_id, expression.clone());
+                self.expressions.insert(*value_id, *expression);
             }
         }
 
@@ -130,10 +130,8 @@ impl Block {
                     continue;
                 }
             }
-            let expression = expression.clone();
-
             self.aliases
-                .entry(expression)
+                .entry(*expression)
                 .and_modify(|aliases| aliases.unify(new_aliases))
                 .or_insert_with(|| new_aliases.clone());
         }
@@ -162,7 +160,7 @@ impl Block {
             if let Some(known_address) = self.get_known_value(address) {
                 self.expressions.insert(result, Expression::Other(known_address));
             } else {
-                let expression = Expression::Dereference(Box::new(Expression::Other(address)));
+                let expression = Expression::Dereference(address);
                 self.expressions.insert(result, expression);
                 // No known aliases to insert for this expression... can we find an alias
                 // even if we don't have a known address? If not we'll have to invalidate all