chore: box ExprValue in Value enum

compiler/noirc_frontend/src/hir/comptime/display.rs

@@ -445,19 +445,25 @@ impl<'value, 'interner> Display for ValuePrinter<'value, 'interner> {
             }
             Value::Zeroed(typ) => write!(f, "(zeroed {typ})"),
             Value::Type(typ) => write!(f, "{}", typ),
-            Value::Expr(ExprValue::Expression(expr)) => {
-                let expr = remove_interned_in_expression_kind(self.interner, expr.clone());
-                write!(f, "{}", expr)
-            }
-            Value::Expr(ExprValue::Statement(statement)) => {
-                write!(f, "{}", remove_interned_in_statement_kind(self.interner, statement.clone()))
-            }
-            Value::Expr(ExprValue::LValue(lvalue)) => {
-                write!(f, "{}", remove_interned_in_lvalue(self.interner, lvalue.clone()))
-            }
-            Value::Expr(ExprValue::Pattern(pattern)) => {
-                write!(f, "{}", remove_interned_in_pattern(self.interner, pattern.clone()))
-            }
+            Value::Expr(expr) => match expr.as_ref() {
+                ExprValue::Expression(expr) => {
+                    let expr = remove_interned_in_expression_kind(self.interner, expr.clone());
+                    write!(f, "{}", expr)
+                }
+                ExprValue::Statement(statement) => {
+                    write!(
+                        f,
+                        "{}",
+                        remove_interned_in_statement_kind(self.interner, statement.clone())
+                    )
+                }
+                ExprValue::LValue(lvalue) => {
+                    write!(f, "{}", remove_interned_in_lvalue(self.interner, lvalue.clone()))
+                }
+                ExprValue::Pattern(pattern) => {
+                    write!(f, "{}", remove_interned_in_pattern(self.interner, pattern.clone()))
+                }
+            },
             Value::TypedExpr(TypedExpr::ExprId(id)) => {
                 let hir_expr = self.interner.expression(id);
                 let expr = hir_expr.to_display_ast(self.interner, Span::default());

compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs

@@ -279,7 +279,7 @@ pub(crate) fn get_expr(
     (value, location): (Value, Location),
 ) -> IResult<ExprValue> {
     match value {
-        Value::Expr(expr) => match expr {
+        Value::Expr(expr) => match *expr {
             ExprValue::Expression(ExpressionKind::Interned(id)) => {
                 Ok(ExprValue::Expression(interner.get_expression_kind(id).clone()))
             }
@@ -292,7 +292,7 @@ pub(crate) fn get_expr(
             ExprValue::Pattern(Pattern::Interned(id, _)) => {
                 Ok(ExprValue::Pattern(interner.get_pattern(id).clone()))
             }
-            _ => Ok(expr),
+            _ => Ok(*expr),
         },
         value => type_mismatch(value, Type::Quoted(QuotedType::Expr), location),
     }

compiler/noirc_frontend/src/hir/comptime/value.rs

@@ -71,7 +71,7 @@
     ModuleDefinition(ModuleId),
     Type(Type),
     Zeroed(Type),
-    Expr(ExprValue),
+    Expr(Box<ExprValue>),
     TypedExpr(TypedExpr),
     UnresolvedType(UnresolvedTypeData),
 }
@@ -92,19 +92,19 @@
 
 impl Value {
     pub(crate) fn expression(expr: ExpressionKind) -> Self {
-        Value::Expr(ExprValue::Expression(expr))
+        Value::Expr(Box::new(ExprValue::Expression(expr)))
     }
 
     pub(crate) fn statement(statement: StatementKind) -> Self {
-        Value::Expr(ExprValue::Statement(statement))
+        Value::Expr(Box::new(ExprValue::Statement(statement)))
     }
 
     pub(crate) fn lvalue(lvaue: LValue) -> Self {
-        Value::Expr(ExprValue::LValue(lvaue))
+        Value::Expr(Box::new(ExprValue::LValue(lvaue)))
     }
 
     pub(crate) fn pattern(pattern: Pattern) -> Self {
-        Value::Expr(ExprValue::Pattern(pattern))
+        Value::Expr(Box::new(ExprValue::Pattern(pattern)))
     }
 
     pub(crate) fn get_type(&self) -> Cow<Type> {
@@ -286,15 +286,32 @@
                     }
                 };
             }
-            Value::Expr(ExprValue::Expression(expr)) => expr,
-            Value::Expr(ExprValue::Statement(statement)) => {
-                ExpressionKind::Block(BlockExpression {
-                    statements: vec![Statement { kind: statement, span: location.span }],
-                })
+
+            Value::Expr(ref expr) => {
+                // We need to do some shenanigans to get around the borrow checker here due to using a boxed value.
+
+                // We first do whatever needs a reference to `expr` to avoid partially moving `self`.
+                if matches!(expr.as_ref(), ExprValue::Pattern(_)) {
+                    let typ = Type::Quoted(QuotedType::Expr);
+                    let value = self.display(elaborator.interner).to_string();
+                    return Err(InterpreterError::CannotInlineMacro { typ, value, location });
+                }
+
+                // Now drop this references and move `expr` out of `self` so we don't have to clone it.
+                let Value::Expr(expr) = self else {
+                    unreachable!("Ensured by outer match statement")
+                };
+
+                match *expr {
+                    ExprValue::Expression(expr) => expr,
+                    ExprValue::Statement(statement) => ExpressionKind::Block(BlockExpression {
+                        statements: vec![Statement { kind: statement, span: location.span }],
+                    }),
+                    ExprValue::LValue(lvalue) => lvalue.as_expression().kind,
+                    ExprValue::Pattern(_) => unreachable!("this case is handled above"),
+                }
             }
-            Value::Expr(ExprValue::LValue(lvalue)) => lvalue.as_expression().kind,
-            Value::Expr(ExprValue::Pattern(_))
-            | Value::TypedExpr(..)
+            Value::TypedExpr(..)
             | Value::Pointer(..)
             | Value::StructDefinition(_)
             | Value::TraitConstraint(..)
@@ -477,21 +494,21 @@
             }
             Value::Quoted(tokens) => return Ok(unwrap_rc(tokens)),
             Value::Type(typ) => Token::QuotedType(interner.push_quoted_type(typ)),
-            Value::Expr(ExprValue::Expression(expr)) => {
-                Token::InternedExpr(interner.push_expression_kind(expr))
-            }
-            Value::Expr(ExprValue::Statement(StatementKind::Expression(expr))) => {
-                Token::InternedExpr(interner.push_expression_kind(expr.kind))
-            }
-            Value::Expr(ExprValue::Statement(statement)) => {
-                Token::InternedStatement(interner.push_statement_kind(statement))
-            }
-            Value::Expr(ExprValue::LValue(lvalue)) => {
-                Token::InternedLValue(interner.push_lvalue(lvalue))
-            }
-            Value::Expr(ExprValue::Pattern(pattern)) => {
-                Token::InternedPattern(interner.push_pattern(pattern))
-            }
+            Value::Expr(expr) => match *expr {
+                ExprValue::Expression(expr) => {
+                    Token::InternedExpr(interner.push_expression_kind(expr))
+                }
+                ExprValue::Statement(StatementKind::Expression(expr)) => {
+                    Token::InternedExpr(interner.push_expression_kind(expr.kind))
+                }
+                ExprValue::Statement(statement) => {
+                    Token::InternedStatement(interner.push_statement_kind(statement))
+                }
+                ExprValue::LValue(lvalue) => Token::InternedLValue(interner.push_lvalue(lvalue)),
+                ExprValue::Pattern(pattern) => {
+                    Token::InternedPattern(interner.push_pattern(pattern))
+                }
+            },
             Value::UnresolvedType(typ) => {
                 Token::InternedUnresolvedTypeData(interner.push_unresolved_type_data(typ))
             }