optimize: better length expr boxing for better memory usage

Author: LastLeaf

float-pigment-css/src/parser/property_value/calc.rs

@@ -334,17 +334,11 @@ pub(crate) enum ExpectValueType {
 fn combine_calc_expr(operator: Operator, lhs: CalcExpr, rhs: CalcExpr) -> CalcExpr {
     // Unwrap nested `Length::Expr(Calc(...))` to flatten the expression tree.
     let final_lhs = match lhs {
-        CalcExpr::Length(length_expr) => match *length_expr {
-            Length::Expr(LengthExpr::Calc(calc_expr)) => calc_expr,
-            other => Box::new(CalcExpr::Length(Box::new(other))),
-        },
+        CalcExpr::Length(length_expr) => length_expr.into_calc_expr(),
         other => Box::new(other),
     };
     let final_rhs = match rhs {
-        CalcExpr::Length(length_expr) => match *length_expr {
-            Length::Expr(LengthExpr::Calc(calc_expr)) => calc_expr,
-            other => Box::new(CalcExpr::Length(Box::new(other))),
-        },
+        CalcExpr::Length(length_expr) => length_expr.into_calc_expr(),
         other => Box::new(other),
     };
     match operator {

float-pigment-css/src/parser/property_value/mod.rs

@@ -223,18 +223,18 @@ fn parse_length_inner<'a, 't: 'a, 'i: 't>(
                         env_default_value(parser, properties, st)
                     })
                 })?;
-                return Ok(Length::Expr(LengthExpr::Env(
+                return Ok(Length::Expr(Box::new(LengthExpr::Env(
                     name.into(),
                     Box::new(default_value.unwrap_or(Length::Undefined)),
-                )));
+                ))));
             }
             "calc" => {
                 return parse_calc_inner(parser, properties, st, ExpectValueType::NumberAndLength)
                     .map(|ret| {
                         if let Some(r) = ComputeCalcExpr::<Length>::try_compute(&ret) {
                             return r;
                         }
-                        Length::Expr(LengthExpr::Calc(Box::new(ret)))
+                        Length::Expr(Box::new(LengthExpr::Calc(Box::new(ret))))
                     });
             }
             _ => {}
@@ -401,7 +401,7 @@ pub(crate) fn percentage<'a, 't: 'a, 'i: 't>(
                     if let Some(r) = ComputeCalcExpr::<Length>::try_compute(&ret) {
                         return r;
                     }
-                    Length::Expr(LengthExpr::Calc(Box::new(ret)))
+                    Length::Expr(Box::new(LengthExpr::Calc(Box::new(ret))))
                 });
             }
         }

float-pigment-css/src/typing.rs

@@ -150,7 +150,7 @@ pub enum Length {
     Rpx(f32),
     Em(f32),
     Ratio(f32),
-    Expr(LengthExpr),
+    Expr(Box<LengthExpr>),
     Vmin(f32),
     Vmax(f32),
 }
@@ -188,6 +188,25 @@ impl Length {
         }
     }
 
+    /// Create a new `Length` from a `CalcExpr`.
+    pub fn new_calc_expr(calc_expr: Box<CalcExpr>) -> Self {
+        Self::Expr(Box::new(LengthExpr::Calc(calc_expr)))
+    }
+
+    /// Convert to `Box<CalcExpr>`.
+    /// 
+    /// If the length is already a `CalcExpr`, it will be returned directly.
+    /// Otherwise, it will be wrapped into a new `CalcExpr`.
+    pub fn into_calc_expr(self) -> Box<CalcExpr> {
+        match self {
+            Length::Expr(x) => match *x {
+                LengthExpr::Calc(x) => x,
+                x => Box::new(CalcExpr::Length(Box::new(Length::Expr(Box::new(x))))),
+            },
+            x => Box::new(CalcExpr::Length(Box::new(x))),
+        }
+    }
+
     /// Resolve the length value to `f32`.
     ///
     /// The `relative_length` is used to calculate `...%` length.
@@ -214,7 +233,7 @@ impl Length {
                 }
             }
             Length::Ratio(x) => relative_length * *x,
-            Length::Expr(x) => match x {
+            Length::Expr(x) => match &**x {
                 LengthExpr::Invalid => None?,
                 LengthExpr::Env(name, default_value) => match name.as_str() {
                     "safe-area-inset-left" => media_query_status.env.safe_area_inset_left.to_f32(),
@@ -268,7 +287,7 @@ impl Length {
     ) -> Option<L> {
         let r = match self {
             Length::Undefined | Length::Auto => None?,
-            Length::Expr(x) => match x {
+            Length::Expr(x) => match &**x {
                 LengthExpr::Invalid => None?,
                 LengthExpr::Env(name, default_value) => match name.as_str() {
                     "safe-area-inset-left" => media_query_status.env.safe_area_inset_left,

float-pigment-css/src/typing_stringify.rs

@@ -273,7 +273,7 @@ impl fmt::Display for Length {
                     &tmp
                 }
                 Length::Expr(expr) => {
-                    match expr {
+                    match &**expr {
                         LengthExpr::Calc(calc_expr) => {
                             tmp = calc_expr.to_string();
                             &tmp