2044316 - Implement additional CSSMathValue reification support

Status: ASSIGNED

(Core :: CSS Parsing and Computation, task)

Description

[Jan Varga [:janv]]

This bug tracks additional CSSMathValue reification work as defined in the CSS Typed OM Level 1 specification.

The work focuses on completing support for reifying CSS math expressions into the corresponding CSSMathValue subclasses, including CSSMathProduct, CSSMathNegate, CSSMathInvert, CSSMathMin, CSSMathMax, and CSSMathClamp.

This complements the existing CSSStyleValue reification infrastructure and extends the TypedValue machinery to represent a broader range of numeric expressions in their Typed OM form.

This intentionally excludes CSSMathSum, which already gained most of the required infrastructure to support reification and associated WPT coverage. However, this bug may still include additional improvements that are shared with or benefit CSSMathSum as well.

Comment 1

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Fix expected/actual ordering in CSSNumericValue.parse WPT; r=emilio

Fix the argument order in parse.tentative.html so the actual value is passed
before the expected value.

The previous ordering made failure output confusing because the expected and
actual values were reported in the wrong direction. No behavior change is
intended.

Comment 2

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Reorder CalcNode::to_typed_impl math value match arms; r=emilio

Reorder the math value match arms in CalcNode::to_typed_impl to match the
ordering of the corresponding GenericCalcNode variants.

This makes the code easier to navigate while preparing for additional math
reification support. No functional changes intended.

Comment 3

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CalcNodeWithLevel construction helpers; r=emilio

Add helper constructors for CalcNodeWithLevel and use them at existing call
sites.

This avoids repeating CalcNodeWithLevel initialization boilerplate and makes
the code easier to follow while preparing for additional math reification
support. No functional changes intended.

Comment 4

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CSSMathMin reification support for min() expressions; r=emilio

This patch introduces infrastructure for reifying min() expressions into
CSSMathMin objects as part of the CSS Typed OM implementation.

A new MathMin type is added to represent min() expressions, mirroring the
CSSMathMin object, and is integrated into the MathValue enum.

This is an incremental step, support for additional expressions will be added
in follow-up patches.

Comment 5

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CSSMathMax reification support for max() expressions; r=emilio

This patch introduces infrastructure for reifying max() expressions into
CSSMathMax objects as part of the CSS Typed OM implementation.

A new MathMax type is added to represent max() expressions, mirroring the
CSSMathMax object, and is integrated into the MathValue enum.

This is an incremental step, support for additional expressions will be added
in follow-up patches.

Comment 6

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add OwnedArray helper for fixed-size boxed arrays; r=emilio

Add OwnedArray<T, N>, a cbindgen-friendly replacement for Box<[T; N]>.

OwnedArray provides a compact allocation-backed container for a fixed number
of elements while exposing a simple representation to generated C++ bindings.

This utility is expected to be useful in other cases in the future. As an
immediate follow-up, it will be used by CSSMathClamp reification.

Comment 7

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CSSMathClamp reification support for max() expressions; r=emilio

This patch introduces infrastructure for reifying clamp() expressions into
CSSMathClamp objects as part of the CSS Typed OM implementation.

A new MathClamp type is added to represent clamp() expressions, mirroring the
CSSMathClamp object, and is integrated into the MathValue enum.

This is an incremental step, support for additional expressions will be added
in follow-up patches.

Comment 8

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add WPT coverage for CSSMathNegate reification; r=emilio

Add a CSSNumericValue.parse() test for calc() subtraction.

The new test verifies that subtraction is reified as CSSMathSum containing a
CSSMathNegate argument, matching the math expression reification algorithm.

Comment 9

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CSSMathNegate reification support for subtraction expressions; r=emilio

This patch introduces infrastructure for reifying subtraction expressions into
CSSMathNegate objects as part of the CSS Typed OM implementation.

A new MathNegate type is added to represent subtraction expressions, mirroring
the CSSMathNegate object, and is integrated into the MathValue enum.

This is an incremental step, support for additional expressions will be added
in follow-up patches.

Comment 10

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add initial CSSMathInvert reification plumbing for division expressions; r=emilio

This patch introduces initial plumbing for reifying inversion expressions into
CSSMathInvert objects as part of the CSS Typed OM implementation.

A new MathInvert type is added to represent inversion expressions, mirroring
the CSSMathInvert object, and is integrated into the MathValue enum.

The actual reification remains unsupported for now, because division is
currently simplified or normalized away in all cases (except possibly
expressions involving colors, which are not supported by Typed OM math
expressions).

This is another incremental step; support for additional expressions will be
added in follow-up patches.

Comment 11

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add WPT coverage for CSSMathProduct reification; r=emilio

Add a CSSNumericValue.parse() test for calc() multiplication.

The new test verifies that multiplication is reified as CSSMathProduct and can
contain nested CSSMathSum, CSSMathMin, and CSSMathMax expressions, matching the math expression reification algorithm.

Comment 12

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add CSSMathProduct reification support for multiplication expressions; r=emilio

This patch introduces infrastructure for reifying multiplication expressions
into CSSMathProduct objects as part of the CSS Typed OM implementation.

A new MathProduct type is added to represent multiplication expressions,
mirroring the CSSMathProduct object, and is integrated into the MathValue
enum.

As a final integration step, this patch completes math expression reification
support.

Comment 13

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add WPT coverage for CSSMathInvert reification; r=emilio

Add a CSSNumericValue.parse() test for calc() division.

The new test verifies that division is reified as CSSMathProduct containing a
CSSMathInvert argument, matching the math expression reification algorithm.

Comment 14

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Complete CSSMathInvert reification support for division expressions; r=emilio

This patch completes support for reifying division expressions into
CSSMathInvert objects as part of the CSS Typed OM implementation.

A previous patch added the underlying CSSMathInvert infrastructure, but the
actual reification path remained unsupported. In particular, CSSMathInvert
reification depends on CSSMathProduct support, and division expressions were
believed to be simplified or normalized away before reification.

A new WPT uncovered a valid expression that preserves division in the
calculation tree, allowing the final CSSMathInvert reification support to be
implemented and tested.

Comment 15

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Add WPT coverage for complex CSSMathValue reification; r=emilio

Add a CSSNumericValue.parse() test for calc() complex expression.

The new test verifies that a complex expression is reified as a nested
CSSMathSum containing CSSMathNegate and CSSMathProduct arguments, matching the
math expression reification algorithm.

Comment 16

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Remove uninitialized CSSMathValue object type; r=emilio

Remove the uninitialized CSSMathValue internal type and the corresponding
placeholder handling from CSSMathValue.

All CSSMathValue-derived objects now use concrete internal types, so the
uninitialized placeholder used during incremental implementation is no longer
needed.

Comment 17

[Jan Varga [:janv]]

Attachment: Bug 2044316 - Make CSSNumericValue ToStyle* conversions infallible; r=emilio

Remove the Maybe<> wrappers from the helpers that convert CSSNumericValue
derived objects back to their Style* counterparts for Stylo.

Now that CSSMathValue derived objects always have a concrete internal type,
these conversions no longer need to handle uninitialized values.