From fa2c9b20f59d9e894e393e03fcff4ede596fc4ff Mon Sep 17 00:00:00 2001
From: Alistair Smith <hi@alistair.sh>
Date: Mon, 17 Aug 2026 23:27:27 -0700
Subject: [PATCH 1/6] share one calc parser body per value type

---
 src/css/values/calc.rs  | 209 ++++++++++++++++------------------------
 src/css/values/color.rs |  16 +--
 2 files changed, 93 insertions(+), 132 deletions(-)

diff --git a/src/css/values/calc.rs b/src/css/values/calc.rs
index 9ad34f6ea4f0..414f8c40941c 100644
--- a/src/css/values/calc.rs
+++ b/src/css/values/calc.rs
@@ -220,6 +220,11 @@ impl<V> Calc<V> {
 // `PartialEq for Calc<V>` is provided above with the looser `V: PartialEq +
 // Clone` bound so structural equality is available without `CalcValue`.
 
+/// Resolves a bare identifier inside a math function (e.g. a relative color
+/// channel keyword). Type-erased so the recursive calc parser exists once
+/// per `V` instead of once per call site.
+pub(crate) type ParseIdent<'a, V> = &'a dyn Fn(&[u8]) -> Option<Calc<V>>;
+
 impl<V: CalcValue> Calc<V> {
     fn mul_value_f32(lhs: V, rhs: f32) -> V {
         lhs.mul_f32(rhs)
@@ -280,16 +285,12 @@ impl<V: CalcValue> Calc<V> {
     }
 
     pub fn parse(input: &mut css::Parser) -> CssResult<Self> {
-        fn parse_with_fn<V>(_: (), _: &[u8]) -> Option<Calc<V>> {
-            None
-        }
-        Self::parse_with(input, (), parse_with_fn::<V>)
+        Self::parse_with(input, &|_| None)
     }
 
-    pub(crate) fn parse_with<C: Copy, F: Fn(C, &[u8]) -> Option<Self> + Copy>(
+    pub(crate) fn parse_with(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: F,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
         let location = input.current_source_location();
         // Clone the token before reborrowing `input` so the function
@@ -307,10 +308,9 @@ impl<V: CalcValue> Calc<V> {
             other => return Err(location.new_unexpected_token_error(other)),
         };
 
-        // The closures capture `ctx` + `parse_ident` directly.
         match unit {
             CalcUnit::Calc => {
-                let calc = input.parse_nested_block(|i| Self::parse_sum(i, ctx, parse_ident))?;
+                let calc = input.parse_nested_block(|i| Self::parse_sum(i, parse_ident))?;
                 if matches!(calc, Calc::Value(_) | Calc::Number(_)) {
                     return Ok(calc);
                 }
@@ -318,7 +318,7 @@ impl<V: CalcValue> Calc<V> {
             }
             CalcUnit::Min => {
                 let mut reduced = input.parse_nested_block(|i| {
-                    i.parse_comma_separated(|i| Self::parse_sum(i, ctx, parse_ident))
+                    i.parse_comma_separated(|i| Self::parse_sum(i, parse_ident))
                 })?;
                 // PERF(alloc): i don't like this additional allocation
                 // can we use stack fallback here if the common case is that there will be 1 argument?
@@ -330,7 +330,7 @@ impl<V: CalcValue> Calc<V> {
             }
             CalcUnit::Max => {
                 let mut reduced = input.parse_nested_block(|i| {
-                    i.parse_comma_separated(|i| Self::parse_sum(i, ctx, parse_ident))
+                    i.parse_comma_separated(|i| Self::parse_sum(i, parse_ident))
                 })?;
                 // PERF: i don't like this additional allocation
                 Self::reduce_args(&mut reduced, Ordering::Greater);
@@ -341,11 +341,11 @@ impl<V: CalcValue> Calc<V> {
             }
             CalcUnit::Clamp => {
                 let (mut min, mut center, mut max) = input.parse_nested_block(|i| {
-                    let min = Self::parse_sum(i, ctx, parse_ident)?;
+                    let min = Self::parse_sum(i, parse_ident)?;
                     i.expect_comma()?;
-                    let center = Self::parse_sum(i, ctx, parse_ident)?;
+                    let center = Self::parse_sum(i, parse_ident)?;
                     i.expect_comma()?;
-                    let max = Self::parse_sum(i, ctx, parse_ident)?;
+                    let max = Self::parse_sum(i, parse_ident)?;
                     Ok((Some(min), center, Some(max)))
                 })?;
 
@@ -401,7 +401,6 @@ impl<V: CalcValue> Calc<V> {
                         value: a,
                         interval: b,
                     },
-                    ctx,
                     parse_ident,
                 )
             }),
@@ -420,7 +419,6 @@ impl<V: CalcValue> Calc<V> {
                         dividend: a,
                         divisor: b,
                     },
-                    ctx,
                     parse_ident,
                 )
             }),
@@ -442,41 +440,40 @@ impl<V: CalcValue> Calc<V> {
                         dividend: a,
                         divisor: b,
                     },
-                    ctx,
                     parse_ident,
                 )
             }),
-            CalcUnit::Sin => Self::parse_trig(input, TrigFnKind::Sin, false, ctx, parse_ident),
-            CalcUnit::Cos => Self::parse_trig(input, TrigFnKind::Cos, false, ctx, parse_ident),
-            CalcUnit::Tan => Self::parse_trig(input, TrigFnKind::Tan, false, ctx, parse_ident),
-            CalcUnit::Asin => Self::parse_trig(input, TrigFnKind::Asin, true, ctx, parse_ident),
-            CalcUnit::Acos => Self::parse_trig(input, TrigFnKind::Acos, true, ctx, parse_ident),
-            CalcUnit::Atan => Self::parse_trig(input, TrigFnKind::Atan, true, ctx, parse_ident),
+            CalcUnit::Sin => Self::parse_trig(input, TrigFnKind::Sin, false, parse_ident),
+            CalcUnit::Cos => Self::parse_trig(input, TrigFnKind::Cos, false, parse_ident),
+            CalcUnit::Tan => Self::parse_trig(input, TrigFnKind::Tan, false, parse_ident),
+            CalcUnit::Asin => Self::parse_trig(input, TrigFnKind::Asin, true, parse_ident),
+            CalcUnit::Acos => Self::parse_trig(input, TrigFnKind::Acos, true, parse_ident),
+            CalcUnit::Atan => Self::parse_trig(input, TrigFnKind::Atan, true, parse_ident),
             CalcUnit::Atan2 => input.parse_nested_block(|i| {
-                let res = Self::parse_atan2(i, ctx, parse_ident)?;
+                let res = Self::parse_atan2(i, parse_ident)?;
                 if let Some(v) = V::try_from_angle(res) {
                     return Ok(Calc::Value(Box::new(v)));
                 }
                 Err(i.new_custom_error(css::ParserError::invalid_value))
             }),
             CalcUnit::Pow => input.parse_nested_block(|i| {
-                let a = Self::parse_numeric(i, ctx, parse_ident)?;
+                let a = Self::parse_numeric(i, parse_ident)?;
                 i.expect_comma()?;
-                let b = Self::parse_numeric(i, ctx, parse_ident)?;
+                let b = Self::parse_numeric(i, parse_ident)?;
                 Ok(Calc::Number(a.powf(b)))
             }),
             CalcUnit::Log => input.parse_nested_block(|i| {
-                let value = Self::parse_numeric(i, ctx, parse_ident)?;
+                let value = Self::parse_numeric(i, parse_ident)?;
                 if i.try_parse(|p| p.expect_comma()).is_ok() {
-                    let base = Self::parse_numeric(i, ctx, parse_ident)?;
+                    let base = Self::parse_numeric(i, parse_ident)?;
                     return Ok(Calc::Number(value.log(base)));
                 }
                 Ok(Calc::Number(value.ln()))
             }),
-            CalcUnit::Sqrt => Self::parse_numeric_fn(input, NumericFnOp::Sqrt, ctx, parse_ident),
-            CalcUnit::Exp => Self::parse_numeric_fn(input, NumericFnOp::Exp, ctx, parse_ident),
+            CalcUnit::Sqrt => Self::parse_numeric_fn(input, NumericFnOp::Sqrt, parse_ident),
+            CalcUnit::Exp => Self::parse_numeric_fn(input, NumericFnOp::Exp, parse_ident),
             CalcUnit::Hypot => input.parse_nested_block(|i| {
-                let mut args = i.parse_comma_separated(|i| Self::parse_sum(i, ctx, parse_ident))?;
+                let mut args = i.parse_comma_separated(|i| Self::parse_sum(i, parse_ident))?;
                 let val = Self::parse_hypot(&mut args)?;
                 if let Some(v) = val {
                     return Ok(v);
@@ -484,7 +481,7 @@ impl<V: CalcValue> Calc<V> {
                 Ok(Calc::Function(Box::new(MathFunction::Hypot(args))))
             }),
             CalcUnit::Abs => input.parse_nested_block(|i| {
-                let v = Self::parse_sum(i, ctx, parse_ident)?;
+                let v = Self::parse_sum(i, parse_ident)?;
                 Ok(if let Some(vv) = Self::apply_map(&v, absf) {
                     vv
                 } else {
@@ -492,7 +489,7 @@ impl<V: CalcValue> Calc<V> {
                 })
             }),
             CalcUnit::Sign => input.parse_nested_block(|i| {
-                let v = Self::parse_sum(i, ctx, parse_ident)?;
+                let v = Self::parse_sum(i, parse_ident)?;
                 match &v {
                     Calc::Number(n) => return Ok(Calc::Number(std_math_sign(*n))),
                     Calc::Value(v2) => {
@@ -512,14 +509,13 @@ impl<V: CalcValue> Calc<V> {
         }
     }
 
-    pub(crate) fn parse_numeric_fn<C: Copy>(
+    pub(crate) fn parse_numeric_fn(
         input: &mut css::Parser,
         op: NumericFnOp,
-        ctx: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
         input.parse_nested_block(|i| {
-            let v = Self::parse_numeric(i, ctx, parse_ident)?;
+            let v = Self::parse_numeric(i, parse_ident)?;
             Ok(Calc::Number(match op {
                 NumericFnOp::Sqrt => v.sqrt(),
                 NumericFnOp::Exp => v.exp(),
@@ -527,17 +523,16 @@ impl<V: CalcValue> Calc<V> {
         })
     }
 
-    pub(crate) fn parse_math_fn<C: Copy, OC: Copy>(
+    pub(crate) fn parse_math_fn<OC: Copy>(
         input: &mut css::Parser,
         ctx_for_op_and_fallback: OC,
         op: fn(OC, f32, f32) -> f32,
         fallback: fn(OC, Self, Self) -> MathFunction<V>,
-        ctx_for_parse_ident: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
-        let a = Self::parse_sum(input, ctx_for_parse_ident, parse_ident)?;
+        let a = Self::parse_sum(input, parse_ident)?;
         input.expect_comma()?;
-        let b = Self::parse_sum(input, ctx_for_parse_ident, parse_ident)?;
+        let b = Self::parse_sum(input, parse_ident)?;
 
         let val = Self::apply_op(&a, &b, ctx_for_op_and_fallback, op)
             .unwrap_or_else(|| Calc::Function(Box::new(fallback(ctx_for_op_and_fallback, a, b))));
@@ -545,12 +540,12 @@ impl<V: CalcValue> Calc<V> {
         Ok(val)
     }
 
-    pub(crate) fn parse_sum<C: Copy, F: Fn(C, &[u8]) -> Option<Self> + Copy>(
+    #[inline(never)]
+    pub(crate) fn parse_sum(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: F,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
-        let mut cur = Self::parse_product(input, ctx, parse_ident)?;
+        let mut cur = Self::parse_product(input, parse_ident)?;
         loop {
             let start = input.state();
             let tok = match input.next_including_whitespace() {
@@ -567,10 +562,10 @@ impl<V: CalcValue> Calc<V> {
                 }
                 let next_tok = input.next()?.clone();
                 if matches!(next_tok, css::Token::Delim(c) if c == b'+' as u32) {
-                    let next = Self::parse_product(input, ctx, parse_ident)?;
+                    let next = Self::parse_product(input, parse_ident)?;
                     cur = cur.add(next, input)?;
                 } else if matches!(next_tok, css::Token::Delim(c) if c == b'-' as u32) {
-                    let mut rhs = Self::parse_product(input, ctx, parse_ident)?;
+                    let mut rhs = Self::parse_product(input, parse_ident)?;
                     rhs = rhs.mul_f32(-1.0);
                     cur = cur.add(rhs, input)?;
                 } else {
@@ -585,12 +580,12 @@ impl<V: CalcValue> Calc<V> {
         Ok(cur)
     }
 
-    pub(crate) fn parse_product<C: Copy, F: Fn(C, &[u8]) -> Option<Self> + Copy>(
+    #[inline(never)]
+    pub(crate) fn parse_product(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: F,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
-        let mut node = Self::parse_value(input, ctx, parse_ident)?;
+        let mut node = Self::parse_value(input, parse_ident)?;
         loop {
             let start = input.state();
             let tok = match input.next() {
@@ -603,7 +598,7 @@ impl<V: CalcValue> Calc<V> {
 
             if matches!(tok, css::Token::Delim(c) if *c == b'*' as u32) {
                 // At least one of the operands must be a number.
-                let rhs = Self::parse_value(input, ctx, parse_ident)?;
+                let rhs = Self::parse_value(input, parse_ident)?;
                 if let Calc::Number(n) = rhs {
                     node = node.mul_f32(n);
                 } else if let Calc::Number(val) = node {
@@ -613,7 +608,7 @@ impl<V: CalcValue> Calc<V> {
                     return Err(input.new_unexpected_token_error(css::Token::Delim(b'*' as u32)));
                 }
             } else if matches!(tok, css::Token::Delim(c) if *c == b'/' as u32) {
-                let rhs = Self::parse_value(input, ctx, parse_ident)?;
+                let rhs = Self::parse_value(input, parse_ident)?;
                 if let Calc::Number(val) = rhs {
                     if val != 0.0 {
                         node = node.mul_f32(1.0 / val);
@@ -629,10 +624,10 @@ impl<V: CalcValue> Calc<V> {
         Ok(node)
     }
 
-    pub(crate) fn parse_value<C: Copy, F: Fn(C, &[u8]) -> Option<Self> + Copy>(
+    #[inline(never)]
+    pub(crate) fn parse_value(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: F,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
         // Parse nested calc() and other math functions.
         match input.try_parse(Self::parse) {
@@ -668,7 +663,7 @@ impl<V: CalcValue> Calc<V> {
         }
 
         if input.try_parse(|p| p.expect_parenthesis_block()).is_ok() {
-            return input.parse_nested_block(|i| Self::parse_sum(i, ctx, parse_ident));
+            return input.parse_nested_block(|i| Self::parse_sum(i, parse_ident));
         }
 
         if let Ok(num) = input.try_parse(|p| p.expect_number()) {
@@ -690,7 +685,7 @@ impl<V: CalcValue> Calc<V> {
                 other => Err(p.new_unexpected_token_error(other)),
             }
         }) {
-            if let Some(c) = parse_ident(ctx, ident) {
+            if let Some(c) = parse_ident(ident) {
                 return Ok(c);
             }
             return Err(location.new_unexpected_token_error(css::Token::Ident(ident)));
@@ -700,12 +695,11 @@ impl<V: CalcValue> Calc<V> {
         Ok(Calc::Value(Box::new(value)))
     }
 
-    pub(crate) fn parse_trig<C: Copy>(
+    pub(crate) fn parse_trig(
         input: &mut css::Parser,
         trig_fn_kind: TrigFnKind,
         to_angle: bool,
-        ctx: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Self> {
         let trig_fn = move |x: f32| -> f32 {
             match trig_fn_kind {
@@ -719,20 +713,7 @@ impl<V: CalcValue> Calc<V> {
         };
 
         input.parse_nested_block(|i| {
-            // Wrap `parse_ident` to project `Calc<V>::Number` into
-            // `Calc<Angle>::Number`.
-            let parse_ident_fn = |_self: (), ident: &[u8]| -> Option<Calc<Angle>> {
-                let v = parse_ident(ctx, ident)?;
-                if let Calc::Number(n) = v {
-                    Some(Calc::Number(n))
-                } else {
-                    None
-                }
-            };
-            // ctx is `()` and the
-            // outer closure captures `ctx`/`parse_ident` (both `Copy`, satisfying
-            // `parse_sum`'s `C: Copy` / `F: Fn(C, &[u8]) -> Option<Self> + Copy`).
-            let v = Calc::<Angle>::parse_sum(i, (), parse_ident_fn)?;
+            let v = Calc::<Angle>::parse_sum(i, &Self::number_ident(parse_ident))?;
 
             let rad: f32 = 'rad: {
                 match &v {
@@ -758,21 +739,22 @@ impl<V: CalcValue> Calc<V> {
         })
     }
 
-    pub(crate) fn parse_ident_none<C, Value>(_: C, _: &[u8]) -> Option<Calc<Value>> {
-        None
+    /// Projects `Calc<V>::Number` idents into `Calc<W>::Number` for the
+    /// number-only sub-parsers (trig, atan2, numeric).
+    fn number_ident<'a, W>(
+        parse_ident: ParseIdent<'a, V>,
+    ) -> impl Fn(&[u8]) -> Option<Calc<W>> + 'a {
+        move |ident| match parse_ident(ident)? {
+            Calc::Number(n) => Some(Calc::Number(n)),
+            _ => None,
+        }
     }
 
-    pub(crate) fn parse_atan2<C: Copy>(
+    pub(crate) fn parse_atan2(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Angle> {
-        let angle_ident = move |c: C, ident: &[u8]| -> Option<Calc<Angle>> {
-            match parse_ident(c, ident)? {
-                Calc::Number(n) => Some(Calc::Number(n)),
-                _ => None,
-            }
-        };
+        let angle_ident = Self::number_ident::<Angle>(parse_ident);
 
         let before_args = input.state();
         let failures_before = input.math_fn_parse_failures();
@@ -791,10 +773,10 @@ impl<V: CalcValue> Calc<V> {
                 Err(input.new_custom_error(css::ParserError::invalid_value))
             };
 
-        match Calc::<Angle>::parse_sum(input, ctx, angle_ident) {
+        match Calc::<Angle>::parse_sum(input, &angle_ident) {
             Ok(a) => {
                 input.expect_comma()?;
-                match Calc::<Angle>::parse_sum(input, ctx, angle_ident) {
+                match Calc::<Angle>::parse_sum(input, &angle_ident) {
                     Ok(b) => {
                         if let Ok(v) = reconcile(input, &a, &b) {
                             return Ok(v);
@@ -817,35 +799,26 @@ impl<V: CalcValue> Calc<V> {
             }
         }
 
-        if let Ok(v) = try_parse_atan2_args::<C, Length>(input, ctx) {
+        if let Ok(v) = try_parse_atan2_args::<Length>(input) {
             return Ok(v);
         }
-        if let Ok(v) = try_parse_atan2_args::<C, Percentage>(input, ctx) {
+        if let Ok(v) = try_parse_atan2_args::<Percentage>(input) {
             return Ok(v);
         }
-        if let Ok(v) = try_parse_atan2_args::<C, Time>(input, ctx) {
+        if let Ok(v) = try_parse_atan2_args::<Time>(input) {
             return Ok(v);
         }
 
-        let parse_ident_fn = move |c: C, ident: &[u8]| -> Option<Calc<CSSNumber>> {
-            let v = parse_ident(c, ident)?;
-            if let Calc::Number(n) = v {
-                Some(Calc::Number(n))
-            } else {
-                None
-            }
-        };
-        Calc::<CSSNumber>::parse_atan2_args(input, ctx, parse_ident_fn)
+        Calc::<CSSNumber>::parse_atan2_args(input, &Self::number_ident(parse_ident))
     }
 
-    pub(crate) fn parse_atan2_args<C: Copy>(
+    pub(crate) fn parse_atan2_args(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<Angle> {
-        let a = Self::parse_sum(input, ctx, parse_ident)?;
+        let a = Self::parse_sum(input, parse_ident)?;
         input.expect_comma()?;
-        let b = Self::parse_sum(input, ctx, parse_ident)?;
+        let b = Self::parse_sum(input, parse_ident)?;
 
         if let (Calc::Value(av), Calc::Value(bv)) = (&a, &b) {
             if let Some(v) = av.try_op_to(&**bv, (), |_, x, y| Angle::Rad(x.atan2(y))) {
@@ -862,20 +835,12 @@ impl<V: CalcValue> Calc<V> {
         Err(input.new_custom_error(css::ParserError::invalid_value))
     }
 
-    pub(crate) fn parse_numeric<C: Copy>(
+    pub(crate) fn parse_numeric(
         input: &mut css::Parser,
-        ctx: C,
-        parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
+        parse_ident: ParseIdent<'_, V>,
     ) -> CssResult<f32> {
-        let parse_ident_fn = move |c: C, ident: &[u8]| -> Option<Calc<CSSNumber>> {
-            let v = parse_ident(c, ident)?;
-            if let Calc::Number(n) = v {
-                Some(Calc::Number(n))
-            } else {
-                None
-            }
-        };
-        let v: Calc<CSSNumber> = Calc::<CSSNumber>::parse_sum(input, ctx, parse_ident_fn)?;
+        let v: Calc<CSSNumber> =
+            Calc::<CSSNumber>::parse_sum(input, &Self::number_ident(parse_ident))?;
         let val = match v {
             Calc::Number(n) => n,
             Calc::Value(v) => *v,
@@ -1109,12 +1074,8 @@ impl<V: CalcValue> Calc<V> {
 }
 
 #[inline]
-fn try_parse_atan2_args<C: Copy, Value: CalcValue>(
-    input: &mut css::Parser,
-    ctx: C,
-) -> CssResult<Angle> {
-    let func = Calc::<Value>::parse_ident_none::<C, Value>;
-    input.try_parse(|i| Calc::<Value>::parse_atan2_args(i, ctx, func))
+fn try_parse_atan2_args<Value: CalcValue>(input: &mut css::Parser) -> CssResult<Angle> {
+    input.try_parse(|i| Calc::<Value>::parse_atan2_args(i, &|_| None))
 }
 
 #[derive(Copy, Clone)]
diff --git a/src/css/values/color.rs b/src/css/values/color.rs
index 0bb221f293cc..f19c152a86a8 100644
--- a/src/css/values/color.rs
+++ b/src/css/values/color.rs
@@ -2105,8 +2105,8 @@ impl RelativeComponentParser {
 
         // `Calc::Value` is `Box<V>`, so box the temporary `Angle`.
         if let Ok(value) = input.try_parse(|i| {
-            match Calc::<Angle>::parse_with(i, this, |ctx, ident| {
-                let value = ctx.get_ident(ident, allowed)?;
+            match Calc::<Angle>::parse_with(i, &|ident| {
+                let value = this.get_ident(ident, allowed)?;
                 Some(Calc::Value(Box::new(Angle::Deg(value))))
             }) {
                 Ok(Calc::Value(v)) => Ok(*v),
@@ -2139,8 +2139,8 @@ impl RelativeComponentParser {
         }
 
         if let Ok(value) = input.try_parse(|i| {
-            match Calc::<Percentage>::parse_with(i, this, |ctx, ident| {
-                let v = ctx.get_ident(ident, allowed)?;
+            match Calc::<Percentage>::parse_with(i, &|ident| {
+                let v = this.get_ident(ident, allowed)?;
                 // value variant is a *Percentage
                 // but we immediately dereference it and discard the pointer
                 // so using a field on this closure struct instead of making a gratuitous allocation
@@ -2166,8 +2166,8 @@ impl RelativeComponentParser {
         }
 
         if let Ok(value) = input.try_parse(|i| {
-            let calc_value = match Calc::<Percentage>::parse_with(i, this, |ctx, ident| {
-                let v = ctx.get_ident(ident, ChannelType::PERCENTAGE)?;
+            let calc_value = match Calc::<Percentage>::parse_with(i, &|ident| {
+                let v = this.get_ident(ident, ChannelType::PERCENTAGE)?;
                 Some(Calc::Value(Box::new(Percentage { v })))
             }) {
                 Ok(v) => v,
@@ -2217,8 +2217,8 @@ impl RelativeComponentParser {
         this: &RelativeComponentParser,
         allowed_types: ChannelType,
     ) -> CssResult<f32> {
-        if let Ok(calc_val) = Calc::<f32>::parse_with(input, this, |ctx, ident| {
-            let v = ctx.get_ident(ident, allowed_types)?;
+        if let Ok(calc_val) = Calc::<f32>::parse_with(input, &|ident| {
+            let v = this.get_ident(ident, allowed_types)?;
             Some(Calc::Number(v))
         }) {
             // PERF: I don't like this redundant allocation

From 1885542befc44cfd6f8a59cba01a31dc10a5c8a1 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 18 Aug 2026 07:01:41 +0000
Subject: [PATCH 2/6] css: drop a stale no-allocation comment from the
 percentage ident closure

---
 src/css/values/color.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/css/values/color.rs b/src/css/values/color.rs
index f19c152a86a8..78835f547a1b 100644
--- a/src/css/values/color.rs
+++ b/src/css/values/color.rs
@@ -2141,9 +2141,6 @@ impl RelativeComponentParser {
         if let Ok(value) = input.try_parse(|i| {
             match Calc::<Percentage>::parse_with(i, &|ident| {
                 let v = this.get_ident(ident, allowed)?;
-                // value variant is a *Percentage
-                // but we immediately dereference it and discard the pointer
-                // so using a field on this closure struct instead of making a gratuitous allocation
                 Some(Calc::Value(Box::new(Percentage { v })))
             }) {
                 Ok(Calc::Value(v)) => Ok(*v),

From af9115eb4a9541ba7b0969fb56e3747e68c5dcbe Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 18 Aug 2026 07:28:08 +0000
Subject: [PATCH 3/6] css: pin the calc parser to one instance per value type

Reads the symbol table of the bun binary under test and checks that
Calc<V>::parse_sum, parse_product and parse_value exist once per value
type. With the generic resolver pair they existed once per call site (24
copies each for Calc<Angle> and Calc<f32>). Skipped when the binary has
no symbol table (the stripped release bun) or off Linux.
---
 .../css/calc-parser-monomorphization.test.ts  | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 test/js/bun/css/calc-parser-monomorphization.test.ts

diff --git a/test/js/bun/css/calc-parser-monomorphization.test.ts b/test/js/bun/css/calc-parser-monomorphization.test.ts
new file mode 100644
index 000000000000..87a13fa031ea
--- /dev/null
+++ b/test/js/bun/css/calc-parser-monomorphization.test.ts
@@ -0,0 +1,39 @@
+import { $ } from "bun";
+import { expect, test } from "bun:test";
+import { bunExe, isLinux } from "harness";
+
+// The css math function parser (src/css/values/calc.rs) takes its identifier
+// resolver as a `&dyn Fn` (`ParseIdent`), so the mutually recursive
+// parse_sum/parse_product/parse_value are compiled once per value type.
+// Threading a generic closure through them again compiles the whole parser once
+// per call site instead (61 copies of each function, a few hundred KB of the
+// binary) and nothing else notices, so this pins the instance count.
+//
+// Reads the static symbol table, which the stripped release `bun` does not
+// have; debug, asan and bun-profile binaries do.
+const nm = isLinux ? Bun.which("nm") || Bun.which("llvm-nm") : null;
+const calcSymbols =
+  nm === null
+    ? []
+    : (await $`${nm} -C --defined-only ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text())
+        .split("\n")
+        .filter(Boolean);
+
+test.skipIf(calcSymbols.length === 0)("the math function parser is compiled once per value type", () => {
+  const instances: Record<string, number> = {};
+  for (const line of calcSymbols) {
+    // `<address> <type> <demangled name>`; the name itself can contain spaces.
+    const name = line.replace(/^\S*\s+\S\s+/, "");
+    // A generic method demangles with its type arguments after the name
+    // (`::parse_sum::<(), {closure}>`), one symbol per distinct closure.
+    const match = /^<bun_css::values::calc::Calc<(.+?)>>::(parse_sum|parse_product|parse_value)(::<.*>)?$/.exec(name);
+    if (match === null) continue;
+    const [, valueType, method] = match;
+    const key = `${method} for Calc<${valueType.replaceAll(/bun_css::values::\w+::/g, "")}>`;
+    instances[key] = (instances[key] ?? 0) + 1;
+  }
+
+  const methods = new Set(Object.keys(instances).map(key => key.split(" ")[0]));
+  expect([...methods].sort()).toEqual(["parse_product", "parse_sum", "parse_value"]);
+  expect(instances).toEqual(Object.fromEntries(Object.keys(instances).map(key => [key, 1])));
+});

From e652f210c1ac244428f4885479ca9354e9949438 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 18 Aug 2026 07:39:26 +0000
Subject: [PATCH 4/6] css: skip the calc instance test by build flavor and
 check every parser method per value type

Skipping on release builds explicitly, instead of on empty nm output,
means a missing nm or renamed symbols now fail the test on debug and
asan builds rather than skipping it. The expectation is the full
parse_sum/parse_product/parse_value set for every value type seen.
---
 .../css/calc-parser-monomorphization.test.ts  | 41 ++++++++++---------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/test/js/bun/css/calc-parser-monomorphization.test.ts b/test/js/bun/css/calc-parser-monomorphization.test.ts
index 87a13fa031ea..968e7fde6b45 100644
--- a/test/js/bun/css/calc-parser-monomorphization.test.ts
+++ b/test/js/bun/css/calc-parser-monomorphization.test.ts
@@ -1,6 +1,6 @@
 import { $ } from "bun";
 import { expect, test } from "bun:test";
-import { bunExe, isLinux } from "harness";
+import { bunExe, isASAN, isDebug, isLinux } from "harness";
 
 // The css math function parser (src/css/values/calc.rs) takes its identifier
 // resolver as a `&dyn Fn` (`ParseIdent`), so the mutually recursive
@@ -9,31 +9,34 @@ import { bunExe, isLinux } from "harness";
 // per call site instead (61 copies of each function, a few hundred KB of the
 // binary) and nothing else notices, so this pins the instance count.
 //
-// Reads the static symbol table, which the stripped release `bun` does not
-// have; debug, asan and bun-profile binaries do.
-const nm = isLinux ? Bun.which("nm") || Bun.which("llvm-nm") : null;
-const calcSymbols =
-  nm === null
-    ? []
-    : (await $`${nm} -C --defined-only ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text())
-        .split("\n")
-        .filter(Boolean);
+// Reads the symbol table, which only the unstripped debug and asan binaries
+// have; the release `bun` is stripped.
+test.skipIf(!isLinux || !(isDebug || isASAN))("the math function parser is compiled once per value type", async () => {
+  const nm = Bun.which("nm") || Bun.which("llvm-nm");
+  if (!nm) {
+    throw new Error("nm executable not found. Please install binutils or llvm.");
+  }
+
+  // grep exits 1 when nothing matches; that case fails the assertions below.
+  const symbols = await $`${nm} -C --defined-only ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text();
 
-test.skipIf(calcSymbols.length === 0)("the math function parser is compiled once per value type", () => {
-  const instances: Record<string, number> = {};
-  for (const line of calcSymbols) {
+  const instances: Record<string, Record<string, number>> = {};
+  for (const line of symbols.split("\n")) {
     // `<address> <type> <demangled name>`; the name itself can contain spaces.
     const name = line.replace(/^\S*\s+\S\s+/, "");
     // A generic method demangles with its type arguments after the name
     // (`::parse_sum::<(), {closure}>`), one symbol per distinct closure.
     const match = /^<bun_css::values::calc::Calc<(.+?)>>::(parse_sum|parse_product|parse_value)(::<.*>)?$/.exec(name);
     if (match === null) continue;
-    const [, valueType, method] = match;
-    const key = `${method} for Calc<${valueType.replaceAll(/bun_css::values::\w+::/g, "")}>`;
-    instances[key] = (instances[key] ?? 0) + 1;
+    const valueType = match[1].replaceAll(/bun_css::values::\w+::/g, "");
+    const methods = (instances[valueType] ??= {});
+    methods[match[2]] = (methods[match[2]] ?? 0) + 1;
   }
 
-  const methods = new Set(Object.keys(instances).map(key => key.split(" ")[0]));
-  expect([...methods].sort()).toEqual(["parse_product", "parse_sum", "parse_value"]);
-  expect(instances).toEqual(Object.fromEntries(Object.keys(instances).map(key => [key, 1])));
+  expect(Object.keys(instances)).toContain("f32");
+  expect(instances).toEqual(
+    Object.fromEntries(
+      Object.keys(instances).map(valueType => [valueType, { parse_sum: 1, parse_product: 1, parse_value: 1 }]),
+    ),
+  );
 });

From 422b524a04216c719dde84dc1da2e6c551e9dfd4 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 18 Aug 2026 07:46:56 +0000
Subject: [PATCH 5/6] css: list the calc symbols at module load and without
 sorting

nm on the debug binary takes a few seconds; running it inside the test
counted against the per-test timeout on slow machines. --no-sort halves
the time (both GNU nm and llvm-nm take it).
---
 .../bun/css/calc-parser-monomorphization.test.ts | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/test/js/bun/css/calc-parser-monomorphization.test.ts b/test/js/bun/css/calc-parser-monomorphization.test.ts
index 968e7fde6b45..fb1aa7718733 100644
--- a/test/js/bun/css/calc-parser-monomorphization.test.ts
+++ b/test/js/bun/css/calc-parser-monomorphization.test.ts
@@ -11,15 +11,21 @@ import { bunExe, isASAN, isDebug, isLinux } from "harness";
 //
 // Reads the symbol table, which only the unstripped debug and asan binaries
 // have; the release `bun` is stripped.
-test.skipIf(!isLinux || !(isDebug || isASAN))("the math function parser is compiled once per value type", async () => {
-  const nm = Bun.which("nm") || Bun.which("llvm-nm");
+const hasSymbolTable = isLinux && (isDebug || isASAN);
+const nm = hasSymbolTable ? Bun.which("nm") || Bun.which("llvm-nm") : null;
+
+// Listing the debug binary takes a couple of seconds, so it happens here rather
+// than against the test's own timeout. grep exits 1 when nothing matches; that
+// case fails the assertions below.
+const symbols = nm
+  ? await $`${nm} -C --defined-only --no-sort ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text()
+  : "";
+
+test.skipIf(!hasSymbolTable)("the math function parser is compiled once per value type", () => {
   if (!nm) {
     throw new Error("nm executable not found. Please install binutils or llvm.");
   }
 
-  // grep exits 1 when nothing matches; that case fails the assertions below.
-  const symbols = await $`${nm} -C --defined-only ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text();
-
   const instances: Record<string, Record<string, number>> = {};
   for (const line of symbols.split("\n")) {
     // `<address> <type> <demangled name>`; the name itself can contain spaces.

From c776b6a29395404e45d0498929bd6d6a342fb17e Mon Sep 17 00:00:00 2001
From: Alistair Smith <hi@alistair.sh>
Date: Tue, 18 Aug 2026 01:20:58 -0700
Subject: [PATCH 6/6] Delete
 test/js/bun/css/calc-parser-monomorphization.test.ts

---
 .../css/calc-parser-monomorphization.test.ts  | 48 -------------------
 1 file changed, 48 deletions(-)
 delete mode 100644 test/js/bun/css/calc-parser-monomorphization.test.ts

diff --git a/test/js/bun/css/calc-parser-monomorphization.test.ts b/test/js/bun/css/calc-parser-monomorphization.test.ts
deleted file mode 100644
index fb1aa7718733..000000000000
--- a/test/js/bun/css/calc-parser-monomorphization.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { $ } from "bun";
-import { expect, test } from "bun:test";
-import { bunExe, isASAN, isDebug, isLinux } from "harness";
-
-// The css math function parser (src/css/values/calc.rs) takes its identifier
-// resolver as a `&dyn Fn` (`ParseIdent`), so the mutually recursive
-// parse_sum/parse_product/parse_value are compiled once per value type.
-// Threading a generic closure through them again compiles the whole parser once
-// per call site instead (61 copies of each function, a few hundred KB of the
-// binary) and nothing else notices, so this pins the instance count.
-//
-// Reads the symbol table, which only the unstripped debug and asan binaries
-// have; the release `bun` is stripped.
-const hasSymbolTable = isLinux && (isDebug || isASAN);
-const nm = hasSymbolTable ? Bun.which("nm") || Bun.which("llvm-nm") : null;
-
-// Listing the debug binary takes a couple of seconds, so it happens here rather
-// than against the test's own timeout. grep exits 1 when nothing matches; that
-// case fails the assertions below.
-const symbols = nm
-  ? await $`${nm} -C --defined-only --no-sort ${bunExe()} | grep 'values::calc::Calc<'`.nothrow().text()
-  : "";
-
-test.skipIf(!hasSymbolTable)("the math function parser is compiled once per value type", () => {
-  if (!nm) {
-    throw new Error("nm executable not found. Please install binutils or llvm.");
-  }
-
-  const instances: Record<string, Record<string, number>> = {};
-  for (const line of symbols.split("\n")) {
-    // `<address> <type> <demangled name>`; the name itself can contain spaces.
-    const name = line.replace(/^\S*\s+\S\s+/, "");
-    // A generic method demangles with its type arguments after the name
-    // (`::parse_sum::<(), {closure}>`), one symbol per distinct closure.
-    const match = /^<bun_css::values::calc::Calc<(.+?)>>::(parse_sum|parse_product|parse_value)(::<.*>)?$/.exec(name);
-    if (match === null) continue;
-    const valueType = match[1].replaceAll(/bun_css::values::\w+::/g, "");
-    const methods = (instances[valueType] ??= {});
-    methods[match[2]] = (methods[match[2]] ?? 0) + 1;
-  }
-
-  expect(Object.keys(instances)).toContain("f32");
-  expect(instances).toEqual(
-    Object.fromEntries(
-      Object.keys(instances).map(valueType => [valueType, { parse_sum: 1, parse_product: 1, parse_value: 1 }]),
-    ),
-  );
-});