LibWeb/CSS: Remove now-unused non-spec calc() resolution code

We're now fully using the simplification algorithm to produce calc
results.

Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp

@@ -728,25 +728,6 @@ static Optional<double> try_get_number(CalculationNode const& child)
     return maybe_number->value();
 }
 
-CalculatedStyleValue::CalculationResult NumericCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    if (m_value.has<Percentage>()) {
-        // NOTE: Depending on whether percentage_basis is set, the caller of resolve() is expecting a raw percentage or
-        //       resolved type.
-        return context.percentage_basis.visit(
-            [&](Empty const&) {
-                VERIFY(numeric_type_from_calculated_style_value(m_value, {}) == numeric_type());
-                return CalculatedStyleValue::CalculationResult::from_value(m_value, context, numeric_type());
-            },
-            [&](auto const& value) {
-                auto const calculated_value = value.percentage_of(m_value.get<Percentage>());
-                return CalculatedStyleValue::CalculationResult::from_value(calculated_value, context, numeric_type_from_calculated_style_value(calculated_value, {}));
-            });
-    }
-
-    return CalculatedStyleValue::CalculationResult::from_value(m_value, context, numeric_type());
-}
-
 RefPtr<StyleValue const> NumericCalculationNode::to_style_value(CalculationContext const& context) const
 {
     // TODO: Clamp values to the range allowed by the context.
@@ -861,22 +842,6 @@ bool SumCalculationNode::contains_percentage() const
     return false;
 }
 
-CalculatedStyleValue::CalculationResult SumCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    Optional<CalculatedStyleValue::CalculationResult> total;
-
-    for (auto& additional_product : m_values) {
-        auto additional_value = additional_product->resolve(context);
-        if (!total.has_value()) {
-            total = additional_value;
-            continue;
-        }
-        total->add(additional_value);
-    }
-
-    return total.value();
-}
-
 NonnullRefPtr<CalculationNode const> SumCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_children_vector(*this, context, resolution_context);
@@ -939,22 +904,6 @@ bool ProductCalculationNode::contains_percentage() const
     return false;
 }
 
-CalculatedStyleValue::CalculationResult ProductCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    Optional<CalculatedStyleValue::CalculationResult> total;
-
-    for (auto& additional_product : m_values) {
-        auto additional_value = additional_product->resolve(context);
-        if (!total.has_value()) {
-            total = additional_value;
-            continue;
-        }
-        total->multiply_by(additional_value);
-    }
-
-    return total.value();
-}
-
 NonnullRefPtr<CalculationNode const> ProductCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_children_vector(*this, context, resolution_context);
@@ -1009,13 +958,6 @@ bool NegateCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult NegateCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto child_value = m_value->resolve(context);
-    child_value.negate();
-    return child_value;
-}
-
 NonnullRefPtr<CalculationNode const> NegateCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1069,13 +1011,6 @@ bool InvertCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult InvertCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto child_value = m_value->resolve(context);
-    child_value.invert();
-    return child_value;
-}
-
 NonnullRefPtr<CalculationNode const> InvertCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1130,24 +1065,6 @@ bool MinCalculationNode::contains_percentage() const
     return false;
 }
 
-CalculatedStyleValue::CalculationResult MinCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    CalculatedStyleValue::CalculationResult smallest_node = m_values.first()->resolve(context);
-    auto smallest_value = smallest_node.value();
-
-    for (size_t i = 1; i < m_values.size(); i++) {
-        auto child_resolved = m_values[i]->resolve(context);
-        auto child_value = child_resolved.value();
-
-        if (child_value < smallest_value) {
-            smallest_value = child_value;
-            smallest_node = child_resolved;
-        }
-    }
-
-    return smallest_node;
-}
-
 NonnullRefPtr<CalculationNode const> MinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_children_vector(*this, context, resolution_context);
@@ -1262,24 +1179,6 @@ bool MaxCalculationNode::contains_percentage() const
     return false;
 }
 
-CalculatedStyleValue::CalculationResult MaxCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    CalculatedStyleValue::CalculationResult largest_node = m_values.first()->resolve(context);
-    auto largest_value = largest_node.value();
-
-    for (size_t i = 1; i < m_values.size(); i++) {
-        auto child_resolved = m_values[i]->resolve(context);
-        auto child_value = child_resolved.value();
-
-        if (child_value > largest_value) {
-            largest_value = child_value;
-            largest_node = child_resolved;
-        }
-    }
-
-    return largest_node;
-}
-
 NonnullRefPtr<CalculationNode const> MaxCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_children_vector(*this, context, resolution_context);
@@ -1344,29 +1243,6 @@ bool ClampCalculationNode::contains_percentage() const
     return m_min_value->contains_percentage() || m_center_value->contains_percentage() || m_max_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult ClampCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto min_node = m_min_value->resolve(context);
-    auto center_node = m_center_value->resolve(context);
-    auto max_node = m_max_value->resolve(context);
-
-    auto min_value = min_node.value();
-    auto center_value = center_node.value();
-    auto max_value = max_node.value();
-
-    // NOTE: The value should be returned as "max(MIN, min(VAL, MAX))"
-    auto chosen_value = max(min_value, min(center_value, max_value));
-    if (chosen_value == min_value)
-        return min_node;
-    if (chosen_value == center_value)
-        return center_node;
-    if (chosen_value == max_value)
-        return max_node;
-
-    // NOTE: Non-finite values end up here.
-    return CalculatedStyleValue::CalculationResult { chosen_value, numeric_type() };
-}
-
 NonnullRefPtr<CalculationNode const> ClampCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     auto simplified_min = simplify_a_calculation_tree(m_min_value, context, resolution_context);
@@ -1467,14 +1343,6 @@ bool AbsCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult AbsCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    if (node_a.value() < 0)
-        node_a.negate();
-    return node_a;
-}
-
 NonnullRefPtr<CalculationNode const> AbsCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1526,20 +1394,6 @@ bool SignCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult SignCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto node_a_value = node_a.value();
-
-    if (node_a_value < 0)
-        return { -1, NumericType {} };
-
-    if (node_a_value > 0)
-        return { 1, NumericType {} };
-
-    return { 0, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> SignCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1607,15 +1461,6 @@ bool SinCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult SinCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto node_a_value = AK::to_radians(node_a.value());
-    auto result = sin(node_a_value);
-
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> SinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1701,15 +1546,6 @@ bool CosCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult CosCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto node_a_value = AK::to_radians(node_a.value());
-    auto result = cos(node_a_value);
-
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> CosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1756,15 +1592,6 @@ bool TanCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult TanCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto node_a_value = AK::to_radians(node_a.value());
-    auto result = tan(node_a_value);
-
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> TanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1811,13 +1638,6 @@ bool AsinCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult AsinCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto result = AK::to_degrees(asin(node_a.value()));
-    return { result, NumericType { NumericType::BaseType::Angle, 1 } };
-}
-
 NonnullRefPtr<CalculationNode const> AsinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1908,13 +1728,6 @@ bool AcosCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult AcosCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto result = AK::to_degrees(acos(node_a.value()));
-    return { result, NumericType { NumericType::BaseType::Angle, 1 } };
-}
-
 NonnullRefPtr<CalculationNode const> AcosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -1961,13 +1774,6 @@ bool AtanCalculationNode::contains_percentage() const
     return m_value->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult AtanCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto result = AK::to_degrees(atan(node_a.value()));
-    return { result, NumericType { NumericType::BaseType::Angle, 1 } };
-}
-
 NonnullRefPtr<CalculationNode const> AtanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -2015,14 +1821,6 @@ bool Atan2CalculationNode::contains_percentage() const
     return m_y->contains_percentage() || m_x->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult Atan2CalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_y->resolve(context);
-    auto node_b = m_x->resolve(context);
-    auto result = AK::to_degrees(atan2(node_a.value(), node_b.value()));
-    return { result, NumericType { NumericType::BaseType::Angle, 1 } };
-}
-
 NonnullRefPtr<CalculationNode const> Atan2CalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_2_children(*this, m_x, m_y, context, resolution_context);
@@ -2089,14 +1887,6 @@ PowCalculationNode::PowCalculationNode(NonnullRefPtr<CalculationNode const> x, N
 
 PowCalculationNode::~PowCalculationNode() = default;
 
-CalculatedStyleValue::CalculationResult PowCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_x->resolve(context);
-    auto node_b = m_y->resolve(context);
-    auto result = pow(node_a.value(), node_b.value());
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> PowCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_2_children(*this, m_x, m_y, context, resolution_context);
@@ -2152,13 +1942,6 @@ SqrtCalculationNode::SqrtCalculationNode(NonnullRefPtr<CalculationNode const> va
 
 SqrtCalculationNode::~SqrtCalculationNode() = default;
 
-CalculatedStyleValue::CalculationResult SqrtCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto result = sqrt(node_a.value());
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> SqrtCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -2223,27 +2006,6 @@ bool HypotCalculationNode::contains_percentage() const
     return false;
 }
 
-CalculatedStyleValue::CalculationResult HypotCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    double square_sum = 0.0;
-    Optional<NumericType> result_type;
-
-    for (auto const& value : m_values) {
-        auto child_resolved = value->resolve(context);
-        auto child_value = child_resolved.value();
-
-        square_sum += child_value * child_value;
-        if (result_type.has_value()) {
-            result_type = result_type->consistent_type(*child_resolved.type());
-        } else {
-            result_type = child_resolved.type();
-        }
-    }
-
-    auto result = sqrt(square_sum);
-    return { result, result_type };
-}
-
 NonnullRefPtr<CalculationNode const> HypotCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_children_vector(*this, context, resolution_context);
@@ -2319,14 +2081,6 @@ LogCalculationNode::LogCalculationNode(NonnullRefPtr<CalculationNode const> x, N
 
 LogCalculationNode::~LogCalculationNode() = default;
 
-CalculatedStyleValue::CalculationResult LogCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_x->resolve(context);
-    auto node_b = m_y->resolve(context);
-    auto result = log2(node_a.value()) / log2(node_b.value());
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> LogCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_2_children(*this, m_x, m_y, context, resolution_context);
@@ -2383,13 +2137,6 @@ ExpCalculationNode::ExpCalculationNode(NonnullRefPtr<CalculationNode const> valu
 
 ExpCalculationNode::~ExpCalculationNode() = default;
 
-CalculatedStyleValue::CalculationResult ExpCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_value->resolve(context);
-    auto result = exp(node_a.value());
-    return { result, NumericType {} };
-}
-
 NonnullRefPtr<CalculationNode const> ExpCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_child(*this, m_value, context, resolution_context);
@@ -2450,44 +2197,6 @@ bool RoundCalculationNode::contains_percentage() const
     return m_x->contains_percentage() || m_y->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult RoundCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_x->resolve(context);
-    auto node_b = m_y->resolve(context);
-
-    auto node_a_value = node_a.value();
-    auto node_b_value = node_b.value();
-
-    auto upper_b = ceil(node_a_value / node_b_value) * node_b_value;
-    auto lower_b = floor(node_a_value / node_b_value) * node_b_value;
-
-    auto resolved_type = node_a.type()->consistent_type(*node_b.type());
-
-    if (m_strategy == RoundingStrategy::Nearest) {
-        auto upper_diff = fabs(upper_b - node_a_value);
-        auto lower_diff = fabs(node_a_value - lower_b);
-        auto rounded_value = upper_diff < lower_diff ? upper_b : lower_b;
-        return { rounded_value, resolved_type };
-    }
-
-    if (m_strategy == RoundingStrategy::Up) {
-        return { upper_b, resolved_type };
-    }
-
-    if (m_strategy == RoundingStrategy::Down) {
-        return { lower_b, resolved_type };
-    }
-
-    if (m_strategy == RoundingStrategy::ToZero) {
-        auto upper_diff = fabs(upper_b);
-        auto lower_diff = fabs(lower_b);
-        auto rounded_value = upper_diff < lower_diff ? upper_b : lower_b;
-        return { rounded_value, resolved_type };
-    }
-
-    VERIFY_NOT_REACHED();
-}
-
 NonnullRefPtr<CalculationNode const> RoundCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     auto simplified_x = simplify_a_calculation_tree(m_x, context, resolution_context);
@@ -2659,19 +2368,6 @@ bool ModCalculationNode::contains_percentage() const
     return m_x->contains_percentage() || m_y->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult ModCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_x->resolve(context);
-    auto node_b = m_y->resolve(context);
-
-    auto node_a_value = node_a.value();
-    auto node_b_value = node_b.value();
-
-    auto quotient = floor(node_a_value / node_b_value);
-    auto value = node_a_value - (node_b_value * quotient);
-    return { value, node_a.type() };
-}
-
 NonnullRefPtr<CalculationNode const> ModCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_2_children(*this, m_x, m_y, context, resolution_context);
@@ -2762,14 +2458,6 @@ bool RemCalculationNode::contains_percentage() const
     return m_x->contains_percentage() || m_y->contains_percentage();
 }
 
-CalculatedStyleValue::CalculationResult RemCalculationNode::resolve(CalculationResolutionContext const& context) const
-{
-    auto node_a = m_x->resolve(context);
-    auto node_b = m_y->resolve(context);
-    auto value = fmod(node_a.value(), node_b.value());
-    return { value, node_a.type() };
-}
-
 NonnullRefPtr<CalculationNode const> RemCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const
 {
     return simplify_2_children(*this, m_x, m_y, context, resolution_context);

Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h

@@ -237,7 +237,6 @@ public:
 
     Optional<NumericType> const& numeric_type() const { return m_numeric_type; }
     virtual bool contains_percentage() const = 0;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const = 0;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const = 0;
     // Step 4 of simpliRfy_a_calculation_tree(). Only valid for math-function nodes.
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const { VERIFY_NOT_REACHED(); }
@@ -268,7 +267,6 @@ public:
 
     virtual bool contains_percentage() const override;
     bool is_in_canonical_unit() const;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; }
 
     RefPtr<StyleValue const> to_style_value(CalculationContext const&) const;
@@ -296,7 +294,6 @@ public:
     ~SumCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
 
     virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@@ -316,7 +313,6 @@ public:
     ~ProductCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
 
     virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@@ -336,7 +332,6 @@ public:
     ~NegateCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
 
     virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@@ -357,7 +352,6 @@ public:
     ~InvertCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
 
     virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@@ -378,7 +372,6 @@ public:
     ~MinCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -399,7 +392,6 @@ public:
     ~MaxCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -420,7 +412,6 @@ public:
     ~ClampCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -443,7 +434,6 @@ public:
     ~AbsCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -463,7 +453,6 @@ public:
     ~SignCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -483,7 +472,6 @@ public:
     ~SinCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -503,7 +491,6 @@ public:
     ~CosCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -523,7 +510,6 @@ public:
     ~TanCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -543,7 +529,6 @@ public:
     ~AsinCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -563,7 +548,6 @@ public:
     ~AcosCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -583,7 +567,6 @@ public:
     ~AtanCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -603,7 +586,6 @@ public:
     ~Atan2CalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -624,7 +606,6 @@ public:
     ~PowCalculationNode();
 
     virtual bool contains_percentage() const override { return false; }
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -645,7 +626,6 @@ public:
     ~SqrtCalculationNode();
 
     virtual bool contains_percentage() const override { return false; }
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -665,7 +645,6 @@ public:
     ~HypotCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -685,7 +664,6 @@ public:
     ~LogCalculationNode();
 
     virtual bool contains_percentage() const override { return false; }
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -706,7 +684,6 @@ public:
     ~ExpCalculationNode();
 
     virtual bool contains_percentage() const override { return false; }
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -726,7 +703,6 @@ public:
     ~RoundCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -750,7 +726,6 @@ public:
     ~ModCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
 
@@ -771,7 +746,6 @@ public:
     ~RemCalculationNode();
 
     virtual bool contains_percentage() const override;
-    virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
     virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;