From c1718100301db2b4ef602fab1c0f664d12bd7182 Mon Sep 17 00:00:00 2001
From: Sam Atkins <atkinssj@serenityos.org>
Date: Tue, 22 Aug 2023 14:13:22 +0100
Subject: [PATCH] LibWeb: Make CalculatedStyleValue::dump() infallible

---
 .../Libraries/LibWeb/CSS/Parser/Parser.cpp    |  4 +-
 .../CSS/StyleValues/CalculatedStyleValue.cpp  | 99 +++++++------------
 .../CSS/StyleValues/CalculatedStyleValue.h    | 54 +++++-----
 3 files changed, 66 insertions(+), 91 deletions(-)

diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
index b9b4535122..5f76228272 100644
--- a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
+++ b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
@@ -6245,9 +6245,9 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override { VERIFY_NOT_REACHED(); }
     virtual void for_each_child_node(AK::Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
 
-    virtual ErrorOr<void> dump(StringBuilder& builder, int indent) const override
+    virtual void dump(StringBuilder& builder, int indent) const override
     {
-        return builder.try_appendff("{: >{}}UNPARSED({})\n", "", indent, m_component_value.to_debug_string());
+        builder.appendff("{: >{}}UNPARSED({})\n", "", indent, m_component_value.to_debug_string());
     }
 
 private:
diff --git a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
index 07f7f133e6..d7343e0334 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
+++ b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
@@ -206,9 +206,9 @@ CalculatedStyleValue::CalculationResult NumericCalculationNode::resolve(Optional
     return m_value;
 }
 
-ErrorOr<void> NumericCalculationNode::dump(StringBuilder& builder, int indent) const
+void NumericCalculationNode::dump(StringBuilder& builder, int indent) const
 {
-    return builder.try_appendff("{: >{}}NUMERIC({})\n", "", indent, m_value.visit([](auto& it) { return it.to_string(); }));
+    builder.appendff("{: >{}}NUMERIC({})\n", "", indent, m_value.visit([](auto& it) { return it.to_string(); }));
 }
 
 NonnullOwnPtr<SumCalculationNode> SumCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values)
@@ -322,12 +322,11 @@ void SumCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     }
 }
 
-ErrorOr<void> SumCalculationNode::dump(StringBuilder& builder, int indent) const
+void SumCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}SUM:\n", "", indent);
     for (auto const& item : m_values)
-        TRY(item->dump(builder, indent + 2));
-    return {};
+        item->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<ProductCalculationNode> ProductCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values)
@@ -446,12 +445,11 @@ void ProductCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Cal
     }
 }
 
-ErrorOr<void> ProductCalculationNode::dump(StringBuilder& builder, int indent) const
+void ProductCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}PRODUCT:\n", "", indent);
     for (auto const& item : m_values)
-        TRY(item->dump(builder, indent + 2));
-    return {};
+        item->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<NegateCalculationNode> NegateCalculationNode::create(NonnullOwnPtr<Web::CSS::CalculationNode> value)
@@ -502,11 +500,10 @@ void NegateCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calc
     callback(m_value);
 }
 
-ErrorOr<void> NegateCalculationNode::dump(StringBuilder& builder, int indent) const
+void NegateCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}NEGATE:\n", "", indent);
-    TRY(m_value->dump(builder, indent + 2));
-    return {};
+    m_value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<InvertCalculationNode> InvertCalculationNode::create(NonnullOwnPtr<Web::CSS::CalculationNode> value)
@@ -564,11 +561,10 @@ void InvertCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calc
     callback(m_value);
 }
 
-ErrorOr<void> InvertCalculationNode::dump(StringBuilder& builder, int indent) const
+void InvertCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}INVERT:\n", "", indent);
-    TRY(m_value->dump(builder, indent + 2));
-    return {};
+    m_value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<MinCalculationNode> MinCalculationNode::create(Vector<NonnullOwnPtr<Web::CSS::CalculationNode>> values)
@@ -646,12 +642,11 @@ void MinCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     }
 }
 
-ErrorOr<void> MinCalculationNode::dump(StringBuilder& builder, int indent) const
+void MinCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}MIN:\n", "", indent);
     for (auto const& value : m_values)
-        TRY(value->dump(builder, indent + 2));
-    return {};
+        value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<MaxCalculationNode> MaxCalculationNode::create(Vector<NonnullOwnPtr<Web::CSS::CalculationNode>> values)
@@ -729,12 +724,11 @@ void MaxCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     }
 }
 
-ErrorOr<void> MaxCalculationNode::dump(StringBuilder& builder, int indent) const
+void MaxCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}MAX:\n", "", indent);
     for (auto const& value : m_values)
-        TRY(value->dump(builder, indent + 2));
-    return {};
+        value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<ClampCalculationNode> ClampCalculationNode::create(NonnullOwnPtr<CalculationNode> min, NonnullOwnPtr<CalculationNode> center, NonnullOwnPtr<CalculationNode> max)
@@ -825,13 +819,12 @@ void ClampCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcu
     callback(m_max_value);
 }
 
-ErrorOr<void> ClampCalculationNode::dump(StringBuilder& builder, int indent) const
+void ClampCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}CLAMP:\n", "", indent);
-    TRY(m_min_value->dump(builder, indent + 2));
-    TRY(m_center_value->dump(builder, indent + 2));
-    TRY(m_max_value->dump(builder, indent + 2));
-    return {};
+    m_min_value->dump(builder, indent + 2);
+    m_center_value->dump(builder, indent + 2);
+    m_max_value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<AbsCalculationNode> AbsCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -891,10 +884,9 @@ void AbsCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_value);
 }
 
-ErrorOr<void> AbsCalculationNode::dump(StringBuilder& builder, int indent) const
+void AbsCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ABS: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<SignCalculationNode> SignCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -956,10 +948,9 @@ void SignCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcul
     callback(m_value);
 }
 
-ErrorOr<void> SignCalculationNode::dump(StringBuilder& builder, int indent) const
+void SignCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}SIGN: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<ConstantCalculationNode> ConstantCalculationNode::create(ConstantType constant)
@@ -1025,10 +1016,9 @@ CalculatedStyleValue::CalculationResult ConstantCalculationNode::resolve([[maybe
     VERIFY_NOT_REACHED();
 }
 
-ErrorOr<void> ConstantCalculationNode::dump(StringBuilder& builder, int indent) const
+void ConstantCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}CONSTANT: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<SinCalculationNode> SinCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1085,10 +1075,9 @@ void SinCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_value);
 }
 
-ErrorOr<void> SinCalculationNode::dump(StringBuilder& builder, int indent) const
+void SinCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}SIN: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<CosCalculationNode> CosCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1145,10 +1134,9 @@ void CosCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_value);
 }
 
-ErrorOr<void> CosCalculationNode::dump(StringBuilder& builder, int indent) const
+void CosCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}COS: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<TanCalculationNode> TanCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1205,10 +1193,9 @@ void TanCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_value);
 }
 
-ErrorOr<void> TanCalculationNode::dump(StringBuilder& builder, int indent) const
+void TanCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}TAN: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<AsinCalculationNode> AsinCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1265,10 +1252,9 @@ void AsinCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcul
     callback(m_value);
 }
 
-ErrorOr<void> AsinCalculationNode::dump(StringBuilder& builder, int indent) const
+void AsinCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ASIN: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<AcosCalculationNode> AcosCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1325,10 +1311,9 @@ void AcosCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcul
     callback(m_value);
 }
 
-ErrorOr<void> AcosCalculationNode::dump(StringBuilder& builder, int indent) const
+void AcosCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ACOS: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<AtanCalculationNode> AtanCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1385,10 +1370,9 @@ void AtanCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcul
     callback(m_value);
 }
 
-ErrorOr<void> AtanCalculationNode::dump(StringBuilder& builder, int indent) const
+void AtanCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ATAN: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<Atan2CalculationNode> Atan2CalculationNode::create(NonnullOwnPtr<CalculationNode> y, NonnullOwnPtr<CalculationNode> x)
@@ -1454,10 +1438,9 @@ void Atan2CalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcu
     callback(m_x);
 }
 
-ErrorOr<void> Atan2CalculationNode::dump(StringBuilder& builder, int indent) const
+void Atan2CalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ATAN2: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<PowCalculationNode> PowCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y)
@@ -1518,10 +1501,9 @@ void PowCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_y);
 }
 
-ErrorOr<void> PowCalculationNode::dump(StringBuilder& builder, int indent) const
+void PowCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}POW: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<SqrtCalculationNode> SqrtCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1573,10 +1555,9 @@ void SqrtCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcul
     callback(m_value);
 }
 
-ErrorOr<void> SqrtCalculationNode::dump(StringBuilder& builder, int indent) const
+void SqrtCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}SQRT: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<HypotCalculationNode> HypotCalculationNode::create(Vector<NonnullOwnPtr<Web::CSS::CalculationNode>> values)
@@ -1652,12 +1633,11 @@ void HypotCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcu
     }
 }
 
-ErrorOr<void> HypotCalculationNode::dump(StringBuilder& builder, int indent) const
+void HypotCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}HYPOT:\n", "", indent);
     for (auto const& value : m_values)
-        TRY(value->dump(builder, indent + 2));
-    return {};
+        value->dump(builder, indent + 2);
 }
 
 NonnullOwnPtr<LogCalculationNode> LogCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y)
@@ -1718,10 +1698,9 @@ void LogCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_y);
 }
 
-ErrorOr<void> LogCalculationNode::dump(StringBuilder& builder, int indent) const
+void LogCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}LOG: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<ExpCalculationNode> ExpCalculationNode::create(NonnullOwnPtr<CalculationNode> value)
@@ -1773,10 +1752,9 @@ void ExpCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_value);
 }
 
-ErrorOr<void> ExpCalculationNode::dump(StringBuilder& builder, int indent) const
+void ExpCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}EXP: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<RoundCalculationNode> RoundCalculationNode::create(RoundingStrategy strategy, NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y)
@@ -1876,10 +1854,9 @@ void RoundCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcu
     callback(m_y);
 }
 
-ErrorOr<void> RoundCalculationNode::dump(StringBuilder& builder, int indent) const
+void RoundCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}ROUND: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<ModCalculationNode> ModCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y)
@@ -1953,10 +1930,9 @@ void ModCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_y);
 }
 
-ErrorOr<void> ModCalculationNode::dump(StringBuilder& builder, int indent) const
+void ModCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}MOD: {}\n", "", indent, to_string());
-    return {};
 }
 
 NonnullOwnPtr<RemCalculationNode> RemCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y)
@@ -2029,10 +2005,9 @@ void RemCalculationNode::for_each_child_node(Function<void(NonnullOwnPtr<Calcula
     callback(m_y);
 }
 
-ErrorOr<void> RemCalculationNode::dump(StringBuilder& builder, int indent) const
+void RemCalculationNode::dump(StringBuilder& builder, int indent) const
 {
     builder.appendff("{: >{}}REM: {}\n", "", indent, to_string());
-    return {};
 }
 
 void CalculatedStyleValue::CalculationResult::add(CalculationResult const& other, Optional<Length::ResolutionContext const&> context, PercentageBasis const& percentage_basis)
diff --git a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
index 0869b22a86..1d0c607ce3 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
+++ b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
@@ -240,7 +240,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const = 0;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) = 0;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const = 0;
+    virtual void dump(StringBuilder&, int indent) const = 0;
 
 protected:
     explicit CalculationNode(Type);
@@ -261,7 +261,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit NumericCalculationNode(NumericValue);
@@ -280,7 +280,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
@@ -299,7 +299,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
@@ -318,7 +318,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit NegateCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -337,7 +337,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit InvertCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -356,7 +356,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
@@ -375,7 +375,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
@@ -394,7 +394,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit ClampCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -415,7 +415,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     AbsCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -434,7 +434,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     SignCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -453,7 +453,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     ConstantCalculationNode(ConstantType);
@@ -472,7 +472,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     SinCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -491,7 +491,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     CosCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -510,7 +510,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     TanCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -529,7 +529,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     AsinCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -548,7 +548,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     AcosCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -567,7 +567,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     AtanCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -586,7 +586,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     Atan2CalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -606,7 +606,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit PowCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -626,7 +626,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     SqrtCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -645,7 +645,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     explicit HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
@@ -664,7 +664,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     LogCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -684,7 +684,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     ExpCalculationNode(NonnullOwnPtr<CalculationNode>);
@@ -703,7 +703,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     RoundCalculationNode(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -724,7 +724,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     ModCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
@@ -744,7 +744,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
     virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
 
-    virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
+    virtual void dump(StringBuilder&, int indent) const override;
 
 private:
     RemCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);