From 6bbaf54026cceb158807b4ed4967d7c3e0f9c329 Mon Sep 17 00:00:00 2001
From: chriseth <chriseth.github@gmail.com>
Date: Tue, 10 Dec 2024 21:27:14 +0000
Subject: [PATCH] Use rc.

---
 .../src/witgen/jit/symbolic_expression.rs     | 37 ++++++++++---------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/executor/src/witgen/jit/symbolic_expression.rs b/executor/src/witgen/jit/symbolic_expression.rs
index 55a44fecf3..4989ae5273 100644
--- a/executor/src/witgen/jit/symbolic_expression.rs
+++ b/executor/src/witgen/jit/symbolic_expression.rs
@@ -1,6 +1,7 @@
 use std::{
     fmt::{self, Display, Formatter},
     ops::{Add, BitAnd, BitOr, Mul, Neg},
+    rc::Rc,
 };
 
 use powdr_number::FieldElement;
@@ -17,12 +18,12 @@ pub enum SymbolicExpression<T: FieldElement, V> {
     /// A symbolic value known at run-time, referencing either a cell or a local variable.
     Variable(V, Option<RangeConstraint<T>>),
     BinaryOperation(
-        Box<Self>,
+        Rc<Self>,
         BinaryOperator,
-        Box<Self>,
+        Rc<Self>,
         Option<RangeConstraint<T>>,
     ),
-    UnaryOperation(UnaryOperator, Box<Self>, Option<RangeConstraint<T>>),
+    UnaryOperation(UnaryOperator, Rc<Self>, Option<RangeConstraint<T>>),
 }
 
 #[derive(Debug, Clone)]
@@ -141,9 +142,9 @@ impl<T: FieldElement, V: Clone> Add for &SymbolicExpression<T, V> {
                 SymbolicExpression::Concrete(*a + *b)
             }
             _ => SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::Add,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 self.range_constraint()
                     .zip(rhs.range_constraint())
                     .map(|(a, b)| a.combine_sum(&b)),
@@ -165,10 +166,12 @@ impl<T: FieldElement, V: Clone> Neg for &SymbolicExpression<T, V> {
     fn neg(self) -> Self::Output {
         match self {
             SymbolicExpression::Concrete(n) => SymbolicExpression::Concrete(-*n),
-            SymbolicExpression::UnaryOperation(UnaryOperator::Neg, expr, _) => *expr.clone(),
+            SymbolicExpression::UnaryOperation(UnaryOperator::Neg, expr, _) => {
+                expr.as_ref().clone()
+            }
             _ => SymbolicExpression::UnaryOperation(
                 UnaryOperator::Neg,
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 self.range_constraint().map(|rc| rc.multiple(-T::from(1))),
             ),
         }
@@ -200,9 +203,9 @@ impl<T: FieldElement, V: Clone> Mul for &SymbolicExpression<T, V> {
             -self
         } else {
             SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::Mul,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 None,
             )
         }
@@ -232,9 +235,9 @@ impl<T: FieldElement, V: Clone> SymbolicExpression<T, V> {
         } else {
             // TODO other simplifications like `-x / -y => x / y`, `-x / concrete => x / -concrete`, etc.
             SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::Div,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 None,
             )
         }
@@ -246,9 +249,9 @@ impl<T: FieldElement, V: Clone> SymbolicExpression<T, V> {
             self.clone()
         } else {
             SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::IntegerDiv,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 None,
             )
         }
@@ -265,9 +268,9 @@ impl<T: FieldElement, V: Clone> BitAnd for &SymbolicExpression<T, V> {
             SymbolicExpression::Concrete(T::from(0))
         } else {
             SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::BitAnd,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 self.range_constraint()
                     .zip(rhs.range_constraint())
                     .map(|(a, b)| a.conjunction(&b)),
@@ -294,9 +297,9 @@ impl<T: FieldElement, V: Clone> BitOr for &SymbolicExpression<T, V> {
             SymbolicExpression::Concrete(T::from(v))
         } else {
             SymbolicExpression::BinaryOperation(
-                Box::new(self.clone()),
+                Rc::new(self.clone()),
                 BinaryOperator::BitOr,
-                Box::new(rhs.clone()),
+                Rc::new(rhs.clone()),
                 None,
             )
         }