diff --git a/Libraries/LibWeb/CSS/Interpolation.cpp b/Libraries/LibWeb/CSS/Interpolation.cpp index d30084ce081..55ecb4dd426 100644 --- a/Libraries/LibWeb/CSS/Interpolation.cpp +++ b/Libraries/LibWeb/CSS/Interpolation.cpp @@ -536,7 +536,7 @@ NonnullRefPtr interpolate_value(DOM::Element& element, Calc } }; - static auto to_calculation_node = [calculation_context](CSSStyleValue const& value) -> NonnullOwnPtr { + static auto to_calculation_node = [calculation_context](CSSStyleValue const& value) -> NonnullRefPtr { switch (value.type()) { case CSSStyleValue::Type::Angle: return NumericCalculationNode::create(value.as_angle().angle(), calculation_context); @@ -565,7 +565,7 @@ NonnullRefPtr interpolate_value(DOM::Element& element, Calc auto interpolated_from = interpolate_value(element, calculation_context, from, from_base_type_and_default->default_value, delta); auto interpolated_to = interpolate_value(element, calculation_context, to_base_type_and_default->default_value, to, delta); - Vector> values; + Vector> values; values.ensure_capacity(2); values.unchecked_append(to_calculation_node(interpolated_from)); values.unchecked_append(to_calculation_node(interpolated_to)); diff --git a/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Libraries/LibWeb/CSS/Parser/Parser.cpp index 370e5ec5364..7d9996677c5 100644 --- a/Libraries/LibWeb/CSS/Parser/Parser.cpp +++ b/Libraries/LibWeb/CSS/Parser/Parser.cpp @@ -1953,7 +1953,7 @@ RefPtr Parser::parse_calculated_value(ComponentValue const return CalculatedStyleValue::create(function_node.release_nonnull(), function_type.release_value(), context); } -OwnPtr Parser::parse_a_calc_function_node(Function const& function, CalculationContext const& context) +RefPtr Parser::parse_a_calc_function_node(Function const& function, CalculationContext const& context) { auto context_guard = push_temporary_value_parsing_context(FunctionContext { function.name }); @@ -9257,11 +9257,11 @@ LengthOrCalculated Parser::Parser::parse_as_sizes_attribute(DOM::Element const& return Length(100, Length::Type::Vw); } -OwnPtr Parser::convert_to_calculation_node(CalcParsing::Node const& node, CalculationContext const& context) +RefPtr Parser::convert_to_calculation_node(CalcParsing::Node const& node, CalculationContext const& context) { return node.visit( - [this, &context](NonnullOwnPtr const& product_node) -> OwnPtr { - Vector> children; + [this, &context](NonnullOwnPtr const& product_node) -> RefPtr { + Vector> children; children.ensure_capacity(product_node->children.size()); for (auto const& child : product_node->children) { @@ -9274,8 +9274,8 @@ OwnPtr Parser::convert_to_calculation_node(CalcParsing::Node co return ProductCalculationNode::create(move(children)); }, - [this, &context](NonnullOwnPtr const& sum_node) -> OwnPtr { - Vector> children; + [this, &context](NonnullOwnPtr const& sum_node) -> RefPtr { + Vector> children; children.ensure_capacity(sum_node->children.size()); for (auto const& child : sum_node->children) { @@ -9288,17 +9288,17 @@ OwnPtr Parser::convert_to_calculation_node(CalcParsing::Node co return SumCalculationNode::create(move(children)); }, - [this, &context](NonnullOwnPtr const& invert_node) -> OwnPtr { + [this, &context](NonnullOwnPtr const& invert_node) -> RefPtr { if (auto child_as_node = convert_to_calculation_node(invert_node->child, context)) return InvertCalculationNode::create(child_as_node.release_nonnull()); return nullptr; }, - [this, &context](NonnullOwnPtr const& negate_node) -> OwnPtr { + [this, &context](NonnullOwnPtr const& negate_node) -> RefPtr { if (auto child_as_node = convert_to_calculation_node(negate_node->child, context)) return NegateCalculationNode::create(child_as_node.release_nonnull()); return nullptr; }, - [this, &context](NonnullRawPtr const& component_value) -> OwnPtr { + [this, &context](NonnullRawPtr const& component_value) -> RefPtr { // NOTE: This is the "process the leaf nodes" part of step 5 of https://drafts.csswg.org/css-values-4/#parse-a-calculation // We divert a little from the spec: Rather than modify an existing tree of values, we construct a new one from that source tree. // This lets us make CalculationNodes immutable. @@ -9375,14 +9375,14 @@ OwnPtr Parser::convert_to_calculation_node(CalcParsing::Node co dbgln_if(CSS_PARSER_DEBUG, "Leftover ComponentValue in calc tree! That probably means the syntax is invalid, but maybe we just didn't implement `{}` yet.", component_value->to_debug_string()); return nullptr; }, - [](CalcParsing::Operator const& op) -> OwnPtr { + [](CalcParsing::Operator const& op) -> RefPtr { dbgln_if(CSS_PARSER_DEBUG, "Leftover Operator {} in calc tree!", op.delim); return nullptr; }); } // https://drafts.csswg.org/css-values-4/#parse-a-calculation -OwnPtr Parser::parse_a_calculation(Vector const& original_values, CalculationContext const& context) +RefPtr Parser::parse_a_calculation(Vector const& original_values, CalculationContext const& context) { // 1. Discard any s from values. // 2. An item in values is an “operator” if it’s a with the value "+", "-", "*", or "/". Otherwise, it’s a “value”. diff --git a/Libraries/LibWeb/CSS/Parser/Parser.h b/Libraries/LibWeb/CSS/Parser/Parser.h index bf4b6a9108c..35704f1a4be 100644 --- a/Libraries/LibWeb/CSS/Parser/Parser.h +++ b/Libraries/LibWeb/CSS/Parser/Parser.h @@ -276,8 +276,8 @@ private: RefPtr parse_calculated_value(ComponentValue const&); RefPtr parse_custom_ident_value(TokenStream&, std::initializer_list blacklist); // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp) - OwnPtr parse_math_function(Function const&, CalculationContext const&); - OwnPtr parse_a_calc_function_node(Function const&, CalculationContext const&); + RefPtr parse_math_function(Function const&, CalculationContext const&); + RefPtr parse_a_calc_function_node(Function const&, CalculationContext const&); RefPtr parse_keyword_value(TokenStream&); RefPtr parse_hue_none_value(TokenStream&); RefPtr parse_solidus_and_alpha_value(TokenStream&); @@ -396,8 +396,8 @@ private: RefPtr parse_grid_area_shorthand_value(TokenStream&); RefPtr parse_grid_shorthand_value(TokenStream&); - OwnPtr convert_to_calculation_node(CalcParsing::Node const&, CalculationContext const&); - OwnPtr parse_a_calculation(Vector const&, CalculationContext const&); + RefPtr convert_to_calculation_node(CalcParsing::Node const&, CalculationContext const&); + RefPtr parse_a_calculation(Vector const&, CalculationContext const&); ParseErrorOr> parse_complex_selector(TokenStream&, SelectorType); ParseErrorOr> parse_compound_selector(TokenStream&); diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp index 3daf4d79a7a..2ea4c99495a 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp @@ -13,7 +13,7 @@ namespace Web::CSS { -static Optional add_the_types(Vector> const& nodes) +static Optional add_the_types(Vector> const& nodes) { Optional left_type; for (auto const& value : nodes) { @@ -58,7 +58,7 @@ static Optional add_the_types(CalculationNode const& a, Calculat return a_and_b_type->added_to(*c_type); } -static Optional multiply_the_types(Vector> const& nodes) +static Optional multiply_the_types(Vector> const& nodes) { // At a * sub-expression, multiply the types of the left and right arguments. // The sub-expression’s type is the returned result. @@ -174,10 +174,10 @@ static CSSNumericType numeric_type_from_calculated_style_value(CalculatedStyleVa }); } -NonnullOwnPtr NumericCalculationNode::create(NumericValue value, CalculationContext const& context) +NonnullRefPtr NumericCalculationNode::create(NumericValue value, CalculationContext const& context) { auto numeric_type = numeric_type_from_calculated_style_value(value, context); - return adopt_own(*new (nothrow) NumericCalculationNode(move(value), numeric_type)); + return adopt_ref(*new (nothrow) NumericCalculationNode(move(value), numeric_type)); } NumericCalculationNode::NumericCalculationNode(NumericValue value, CSSNumericType numeric_type) @@ -231,17 +231,17 @@ bool NumericCalculationNode::equals(CalculationNode const& other) const return m_value == static_cast(other).m_value; } -NonnullOwnPtr SumCalculationNode::create(Vector> values) +NonnullRefPtr SumCalculationNode::create(Vector> values) { // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // At a + or - sub-expression, attempt to add the types of the left and right arguments. // If this returns failure, the entire calculation’s type is failure. // Otherwise, the sub-expression’s type is the returned type. auto numeric_type = add_the_types(values); - return adopt_own(*new (nothrow) SumCalculationNode(move(values), move(numeric_type))); + return adopt_ref(*new (nothrow) SumCalculationNode(move(values), move(numeric_type))); } -SumCalculationNode::SumCalculationNode(Vector> values, Optional numeric_type) +SumCalculationNode::SumCalculationNode(Vector> values, Optional numeric_type) : CalculationNode(Type::Sum, move(numeric_type)) , m_values(move(values)) { @@ -310,16 +310,16 @@ bool SumCalculationNode::equals(CalculationNode const& other) const return true; } -NonnullOwnPtr ProductCalculationNode::create(Vector> values) +NonnullRefPtr ProductCalculationNode::create(Vector> values) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // At a * sub-expression, multiply the types of the left and right arguments. // The sub-expression’s type is the returned result. auto numeric_type = multiply_the_types(values); - return adopt_own(*new (nothrow) ProductCalculationNode(move(values), move(numeric_type))); + return adopt_ref(*new (nothrow) ProductCalculationNode(move(values), move(numeric_type))); } -ProductCalculationNode::ProductCalculationNode(Vector> values, Optional numeric_type) +ProductCalculationNode::ProductCalculationNode(Vector> values, Optional numeric_type) : CalculationNode(Type::Product, move(numeric_type)) , m_values(move(values)) { @@ -388,12 +388,12 @@ bool ProductCalculationNode::equals(CalculationNode const& other) const return true; } -NonnullOwnPtr NegateCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr NegateCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) NegateCalculationNode(move(value))); + return adopt_ref(*new (nothrow) NegateCalculationNode(move(value))); } -NegateCalculationNode::NegateCalculationNode(NonnullOwnPtr value) +NegateCalculationNode::NegateCalculationNode(NonnullRefPtr value) // NOTE: `- foo` doesn't change the type : CalculationNode(Type::Negate, value->numeric_type()) , m_value(move(value)) @@ -434,7 +434,7 @@ bool NegateCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr InvertCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr InvertCalculationNode::create(NonnullRefPtr value) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // At a / sub-expression, let left type be the result of finding the types of its left argument, @@ -443,10 +443,10 @@ NonnullOwnPtr InvertCalculationNode::create(NonnullOwnPtr // NOTE: An InvertCalculationNode only represents the right argument here, and the multiplication // is handled in the parent ProductCalculationNode. auto numeric_type = value->numeric_type().map([](auto& it) { return it.inverted(); }); - return adopt_own(*new (nothrow) InvertCalculationNode(move(value), move(numeric_type))); + return adopt_ref(*new (nothrow) InvertCalculationNode(move(value), move(numeric_type))); } -InvertCalculationNode::InvertCalculationNode(NonnullOwnPtr value, Optional numeric_type) +InvertCalculationNode::InvertCalculationNode(NonnullRefPtr value, Optional numeric_type) : CalculationNode(Type::Invert, move(numeric_type)) , m_value(move(value)) { @@ -486,15 +486,15 @@ bool InvertCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr MinCalculationNode::create(Vector> values) +NonnullRefPtr MinCalculationNode::create(Vector> values) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(values); - return adopt_own(*new (nothrow) MinCalculationNode(move(values), move(numeric_type))); + return adopt_ref(*new (nothrow) MinCalculationNode(move(values), move(numeric_type))); } -MinCalculationNode::MinCalculationNode(Vector> values, Optional numeric_type) +MinCalculationNode::MinCalculationNode(Vector> values, Optional numeric_type) : CalculationNode(Type::Min, move(numeric_type)) , m_values(move(values)) { @@ -565,15 +565,15 @@ bool MinCalculationNode::equals(CalculationNode const& other) const return true; } -NonnullOwnPtr MaxCalculationNode::create(Vector> values) +NonnullRefPtr MaxCalculationNode::create(Vector> values) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(values); - return adopt_own(*new (nothrow) MaxCalculationNode(move(values), move(numeric_type))); + return adopt_ref(*new (nothrow) MaxCalculationNode(move(values), move(numeric_type))); } -MaxCalculationNode::MaxCalculationNode(Vector> values, Optional numeric_type) +MaxCalculationNode::MaxCalculationNode(Vector> values, Optional numeric_type) : CalculationNode(Type::Max, move(numeric_type)) , m_values(move(values)) { @@ -644,15 +644,15 @@ bool MaxCalculationNode::equals(CalculationNode const& other) const return true; } -NonnullOwnPtr ClampCalculationNode::create(NonnullOwnPtr min, NonnullOwnPtr center, NonnullOwnPtr max) +NonnullRefPtr ClampCalculationNode::create(NonnullRefPtr min, NonnullRefPtr center, NonnullRefPtr max) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(*min, *center, *max); - return adopt_own(*new (nothrow) ClampCalculationNode(move(min), move(center), move(max), move(numeric_type))); + return adopt_ref(*new (nothrow) ClampCalculationNode(move(min), move(center), move(max), move(numeric_type))); } -ClampCalculationNode::ClampCalculationNode(NonnullOwnPtr min, NonnullOwnPtr center, NonnullOwnPtr max, Optional numeric_type) +ClampCalculationNode::ClampCalculationNode(NonnullRefPtr min, NonnullRefPtr center, NonnullRefPtr max, Optional numeric_type) : CalculationNode(Type::Clamp, move(numeric_type)) , m_min_value(move(min)) , m_center_value(move(center)) @@ -721,12 +721,12 @@ bool ClampCalculationNode::equals(CalculationNode const& other) const && m_max_value->equals(*static_cast(other).m_max_value); } -NonnullOwnPtr AbsCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr AbsCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) AbsCalculationNode(move(value))); + return adopt_ref(*new (nothrow) AbsCalculationNode(move(value))); } -AbsCalculationNode::AbsCalculationNode(NonnullOwnPtr value) +AbsCalculationNode::AbsCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // The type of its contained calculation. : CalculationNode(Type::Abs, value->numeric_type()) @@ -772,12 +772,12 @@ bool AbsCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr SignCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr SignCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) SignCalculationNode(move(value))); + return adopt_ref(*new (nothrow) SignCalculationNode(move(value))); } -SignCalculationNode::SignCalculationNode(NonnullOwnPtr value) +SignCalculationNode::SignCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Sign, CSSNumericType {}) @@ -829,9 +829,9 @@ bool SignCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr ConstantCalculationNode::create(ConstantType constant) +NonnullRefPtr ConstantCalculationNode::create(ConstantType constant) { - return adopt_own(*new (nothrow) ConstantCalculationNode(constant)); + return adopt_ref(*new (nothrow) ConstantCalculationNode(constant)); } ConstantCalculationNode::ConstantCalculationNode(ConstantType constant) @@ -897,12 +897,12 @@ bool ConstantCalculationNode::equals(CalculationNode const& other) const return m_constant == static_cast(other).m_constant; } -NonnullOwnPtr SinCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr SinCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) SinCalculationNode(move(value))); + return adopt_ref(*new (nothrow) SinCalculationNode(move(value))); } -SinCalculationNode::SinCalculationNode(NonnullOwnPtr value) +SinCalculationNode::SinCalculationNode(NonnullRefPtr value) // «[ ]» (empty map). : CalculationNode(Type::Sin, CSSNumericType {}) , m_value(move(value)) @@ -948,12 +948,12 @@ bool SinCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr CosCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr CosCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) CosCalculationNode(move(value))); + return adopt_ref(*new (nothrow) CosCalculationNode(move(value))); } -CosCalculationNode::CosCalculationNode(NonnullOwnPtr value) +CosCalculationNode::CosCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Cos, CSSNumericType {}) @@ -1000,12 +1000,12 @@ bool CosCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr TanCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr TanCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) TanCalculationNode(move(value))); + return adopt_ref(*new (nothrow) TanCalculationNode(move(value))); } -TanCalculationNode::TanCalculationNode(NonnullOwnPtr value) +TanCalculationNode::TanCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Tan, CSSNumericType {}) @@ -1052,12 +1052,12 @@ bool TanCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr AsinCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr AsinCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) AsinCalculationNode(move(value))); + return adopt_ref(*new (nothrow) AsinCalculationNode(move(value))); } -AsinCalculationNode::AsinCalculationNode(NonnullOwnPtr value) +AsinCalculationNode::AsinCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ "angle" → 1 ]». : CalculationNode(Type::Asin, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) @@ -1102,12 +1102,12 @@ bool AsinCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr AcosCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr AcosCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) AcosCalculationNode(move(value))); + return adopt_ref(*new (nothrow) AcosCalculationNode(move(value))); } -AcosCalculationNode::AcosCalculationNode(NonnullOwnPtr value) +AcosCalculationNode::AcosCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ "angle" → 1 ]». : CalculationNode(Type::Acos, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) @@ -1152,12 +1152,12 @@ bool AcosCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr AtanCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr AtanCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) AtanCalculationNode(move(value))); + return adopt_ref(*new (nothrow) AtanCalculationNode(move(value))); } -AtanCalculationNode::AtanCalculationNode(NonnullOwnPtr value) +AtanCalculationNode::AtanCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ "angle" → 1 ]». : CalculationNode(Type::Atan, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) @@ -1202,12 +1202,12 @@ bool AtanCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr Atan2CalculationNode::create(NonnullOwnPtr y, NonnullOwnPtr x) +NonnullRefPtr Atan2CalculationNode::create(NonnullRefPtr y, NonnullRefPtr x) { - return adopt_own(*new (nothrow) Atan2CalculationNode(move(y), move(x))); + return adopt_ref(*new (nothrow) Atan2CalculationNode(move(y), move(x))); } -Atan2CalculationNode::Atan2CalculationNode(NonnullOwnPtr y, NonnullOwnPtr x) +Atan2CalculationNode::Atan2CalculationNode(NonnullRefPtr y, NonnullRefPtr x) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ "angle" → 1 ]». : CalculationNode(Type::Atan2, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) @@ -1257,12 +1257,12 @@ bool Atan2CalculationNode::equals(CalculationNode const& other) const && m_y->equals(*static_cast(other).m_y); } -NonnullOwnPtr PowCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullRefPtr PowCalculationNode::create(NonnullRefPtr x, NonnullRefPtr y) { - return adopt_own(*new (nothrow) PowCalculationNode(move(x), move(y))); + return adopt_ref(*new (nothrow) PowCalculationNode(move(x), move(y))); } -PowCalculationNode::PowCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) +PowCalculationNode::PowCalculationNode(NonnullRefPtr x, NonnullRefPtr y) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Pow, CSSNumericType {}) @@ -1307,12 +1307,12 @@ bool PowCalculationNode::equals(CalculationNode const& other) const && m_y->equals(*static_cast(other).m_y); } -NonnullOwnPtr SqrtCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr SqrtCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) SqrtCalculationNode(move(value))); + return adopt_ref(*new (nothrow) SqrtCalculationNode(move(value))); } -SqrtCalculationNode::SqrtCalculationNode(NonnullOwnPtr value) +SqrtCalculationNode::SqrtCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Sqrt, CSSNumericType {}) @@ -1352,15 +1352,15 @@ bool SqrtCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr HypotCalculationNode::create(Vector> values) +NonnullRefPtr HypotCalculationNode::create(Vector> values) { // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(values); - return adopt_own(*new (nothrow) HypotCalculationNode(move(values), move(numeric_type))); + return adopt_ref(*new (nothrow) HypotCalculationNode(move(values), move(numeric_type))); } -HypotCalculationNode::HypotCalculationNode(Vector> values, Optional numeric_type) +HypotCalculationNode::HypotCalculationNode(Vector> values, Optional numeric_type) : CalculationNode(Type::Hypot, move(numeric_type)) , m_values(move(values)) { @@ -1432,12 +1432,12 @@ bool HypotCalculationNode::equals(CalculationNode const& other) const return true; } -NonnullOwnPtr LogCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullRefPtr LogCalculationNode::create(NonnullRefPtr x, NonnullRefPtr y) { - return adopt_own(*new (nothrow) LogCalculationNode(move(x), move(y))); + return adopt_ref(*new (nothrow) LogCalculationNode(move(x), move(y))); } -LogCalculationNode::LogCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) +LogCalculationNode::LogCalculationNode(NonnullRefPtr x, NonnullRefPtr y) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Log, CSSNumericType {}) @@ -1482,12 +1482,12 @@ bool LogCalculationNode::equals(CalculationNode const& other) const && m_y->equals(*static_cast(other).m_y); } -NonnullOwnPtr ExpCalculationNode::create(NonnullOwnPtr value) +NonnullRefPtr ExpCalculationNode::create(NonnullRefPtr value) { - return adopt_own(*new (nothrow) ExpCalculationNode(move(value))); + return adopt_ref(*new (nothrow) ExpCalculationNode(move(value))); } -ExpCalculationNode::ExpCalculationNode(NonnullOwnPtr value) +ExpCalculationNode::ExpCalculationNode(NonnullRefPtr value) // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // «[ ]» (empty map). : CalculationNode(Type::Exp, CSSNumericType {}) @@ -1527,15 +1527,15 @@ bool ExpCalculationNode::equals(CalculationNode const& other) const return m_value->equals(*static_cast(other).m_value); } -NonnullOwnPtr RoundCalculationNode::create(RoundingStrategy strategy, NonnullOwnPtr x, NonnullOwnPtr y) +NonnullRefPtr RoundCalculationNode::create(RoundingStrategy strategy, NonnullRefPtr x, NonnullRefPtr y) { // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(*x, *y); - return adopt_own(*new (nothrow) RoundCalculationNode(strategy, move(x), move(y), move(numeric_type))); + return adopt_ref(*new (nothrow) RoundCalculationNode(strategy, move(x), move(y), move(numeric_type))); } -RoundCalculationNode::RoundCalculationNode(RoundingStrategy mode, NonnullOwnPtr x, NonnullOwnPtr y, Optional numeric_type) +RoundCalculationNode::RoundCalculationNode(RoundingStrategy mode, NonnullRefPtr x, NonnullRefPtr y, Optional numeric_type) : CalculationNode(Type::Round, move(numeric_type)) , m_strategy(mode) , m_x(move(x)) @@ -1617,15 +1617,15 @@ bool RoundCalculationNode::equals(CalculationNode const& other) const && m_y->equals(*static_cast(other).m_y); } -NonnullOwnPtr ModCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullRefPtr ModCalculationNode::create(NonnullRefPtr x, NonnullRefPtr y) { // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(*x, *y); - return adopt_own(*new (nothrow) ModCalculationNode(move(x), move(y), move(numeric_type))); + return adopt_ref(*new (nothrow) ModCalculationNode(move(x), move(y), move(numeric_type))); } -ModCalculationNode::ModCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y, Optional numeric_type) +ModCalculationNode::ModCalculationNode(NonnullRefPtr x, NonnullRefPtr y, Optional numeric_type) : CalculationNode(Type::Mod, move(numeric_type)) , m_x(move(x)) , m_y(move(y)) @@ -1678,15 +1678,15 @@ bool ModCalculationNode::equals(CalculationNode const& other) const && m_y->equals(*static_cast(other).m_y); } -NonnullOwnPtr RemCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullRefPtr RemCalculationNode::create(NonnullRefPtr x, NonnullRefPtr y) { // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // The result of adding the types of its comma-separated calculations. auto numeric_type = add_the_types(*x, *y); - return adopt_own(*new (nothrow) RemCalculationNode(move(x), move(y), move(numeric_type))); + return adopt_ref(*new (nothrow) RemCalculationNode(move(x), move(y), move(numeric_type))); } -RemCalculationNode::RemCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y, Optional numeric_type) +RemCalculationNode::RemCalculationNode(NonnullRefPtr x, NonnullRefPtr y, Optional numeric_type) : CalculationNode(Type::Rem, move(numeric_type)) , m_x(move(x)) , m_y(move(y)) diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h index 3744e94c3a1..dba48e59df7 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h @@ -65,7 +65,7 @@ public: Optional m_type; }; - static ValueComparingNonnullRefPtr create(NonnullOwnPtr calculation, CSSNumericType resolved_type, CalculationContext context) + static ValueComparingNonnullRefPtr create(NonnullRefPtr calculation, CSSNumericType resolved_type, CalculationContext context) { return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), move(resolved_type), move(context))); } @@ -109,7 +109,7 @@ public: String dump() const; private: - explicit CalculatedStyleValue(NonnullOwnPtr calculation, CSSNumericType resolved_type, CalculationContext context) + explicit CalculatedStyleValue(NonnullRefPtr calculation, CSSNumericType resolved_type, CalculationContext context) : CSSStyleValue(Type::Calculated) , m_resolved_type(move(resolved_type)) , m_calculation(move(calculation)) @@ -120,12 +120,12 @@ private: Optional percentage_resolved_type() const; CSSNumericType m_resolved_type; - NonnullOwnPtr m_calculation; + NonnullRefPtr m_calculation; CalculationContext m_context; }; // https://www.w3.org/TR/css-values-4/#calculation-tree -class CalculationNode { +class CalculationNode : public RefCounted { public: // https://drafts.csswg.org/css-values-4/#calc-constants // https://drafts.csswg.org/css-values-4/#calc-error-constants @@ -255,7 +255,7 @@ private: class NumericCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NumericValue, CalculationContext const&); + static NonnullRefPtr create(NumericValue, CalculationContext const&); ~NumericCalculationNode(); virtual String to_string() const override; @@ -272,7 +272,7 @@ private: class SumCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(Vector>); + static NonnullRefPtr create(Vector>); ~SumCalculationNode(); virtual String to_string() const override; @@ -283,13 +283,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - SumCalculationNode(Vector>, Optional); - Vector> m_values; + SumCalculationNode(Vector>, Optional); + Vector> m_values; }; class ProductCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(Vector>); + static NonnullRefPtr create(Vector>); ~ProductCalculationNode(); virtual String to_string() const override; @@ -300,13 +300,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - ProductCalculationNode(Vector>, Optional); - Vector> m_values; + ProductCalculationNode(Vector>, Optional); + Vector> m_values; }; class NegateCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~NegateCalculationNode(); virtual String to_string() const override; @@ -317,13 +317,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - NegateCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + NegateCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class InvertCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~InvertCalculationNode(); virtual String to_string() const override; @@ -334,13 +334,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - InvertCalculationNode(NonnullOwnPtr, Optional); - NonnullOwnPtr m_value; + InvertCalculationNode(NonnullRefPtr, Optional); + NonnullRefPtr m_value; }; class MinCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(Vector>); + static NonnullRefPtr create(Vector>); ~MinCalculationNode(); virtual String to_string() const override; @@ -351,13 +351,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - MinCalculationNode(Vector>, Optional); - Vector> m_values; + MinCalculationNode(Vector>, Optional); + Vector> m_values; }; class MaxCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(Vector>); + static NonnullRefPtr create(Vector>); ~MaxCalculationNode(); virtual String to_string() const override; @@ -368,13 +368,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - MaxCalculationNode(Vector>, Optional); - Vector> m_values; + MaxCalculationNode(Vector>, Optional); + Vector> m_values; }; class ClampCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr, NonnullRefPtr); ~ClampCalculationNode(); virtual String to_string() const override; @@ -385,15 +385,15 @@ public: virtual bool equals(CalculationNode const&) const override; private: - ClampCalculationNode(NonnullOwnPtr, NonnullOwnPtr, NonnullOwnPtr, Optional); - NonnullOwnPtr m_min_value; - NonnullOwnPtr m_center_value; - NonnullOwnPtr m_max_value; + ClampCalculationNode(NonnullRefPtr, NonnullRefPtr, NonnullRefPtr, Optional); + NonnullRefPtr m_min_value; + NonnullRefPtr m_center_value; + NonnullRefPtr m_max_value; }; class AbsCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~AbsCalculationNode(); virtual String to_string() const override; @@ -404,13 +404,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - AbsCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + AbsCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class SignCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~SignCalculationNode(); virtual String to_string() const override; @@ -421,13 +421,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - SignCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + SignCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class ConstantCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(CalculationNode::ConstantType); + static NonnullRefPtr create(CalculationNode::ConstantType); ~ConstantCalculationNode(); virtual String to_string() const override; @@ -444,7 +444,7 @@ private: class SinCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~SinCalculationNode(); virtual String to_string() const override; @@ -455,13 +455,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - SinCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + SinCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class CosCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~CosCalculationNode(); virtual String to_string() const override; @@ -472,13 +472,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - CosCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + CosCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class TanCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~TanCalculationNode(); virtual String to_string() const override; @@ -489,13 +489,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - TanCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + TanCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class AsinCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~AsinCalculationNode(); virtual String to_string() const override; @@ -506,13 +506,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - AsinCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + AsinCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class AcosCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~AcosCalculationNode(); virtual String to_string() const override; @@ -523,13 +523,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - AcosCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + AcosCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class AtanCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~AtanCalculationNode(); virtual String to_string() const override; @@ -540,13 +540,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - AtanCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + AtanCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class Atan2CalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr); ~Atan2CalculationNode(); virtual String to_string() const override; @@ -557,14 +557,14 @@ public: virtual bool equals(CalculationNode const&) const override; private: - Atan2CalculationNode(NonnullOwnPtr, NonnullOwnPtr); - NonnullOwnPtr m_y; - NonnullOwnPtr m_x; + Atan2CalculationNode(NonnullRefPtr, NonnullRefPtr); + NonnullRefPtr m_y; + NonnullRefPtr m_x; }; class PowCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr); ~PowCalculationNode(); virtual String to_string() const override; @@ -575,14 +575,14 @@ public: virtual bool equals(CalculationNode const&) const override; private: - PowCalculationNode(NonnullOwnPtr, NonnullOwnPtr); - NonnullOwnPtr m_x; - NonnullOwnPtr m_y; + PowCalculationNode(NonnullRefPtr, NonnullRefPtr); + NonnullRefPtr m_x; + NonnullRefPtr m_y; }; class SqrtCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~SqrtCalculationNode(); virtual String to_string() const override; @@ -593,13 +593,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - SqrtCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + SqrtCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class HypotCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(Vector>); + static NonnullRefPtr create(Vector>); ~HypotCalculationNode(); virtual String to_string() const override; @@ -610,13 +610,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - HypotCalculationNode(Vector>, Optional); - Vector> m_values; + HypotCalculationNode(Vector>, Optional); + Vector> m_values; }; class LogCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr); ~LogCalculationNode(); virtual String to_string() const override; @@ -627,14 +627,14 @@ public: virtual bool equals(CalculationNode const&) const override; private: - LogCalculationNode(NonnullOwnPtr, NonnullOwnPtr); - NonnullOwnPtr m_x; - NonnullOwnPtr m_y; + LogCalculationNode(NonnullRefPtr, NonnullRefPtr); + NonnullRefPtr m_x; + NonnullRefPtr m_y; }; class ExpCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr); ~ExpCalculationNode(); virtual String to_string() const override; @@ -645,13 +645,13 @@ public: virtual bool equals(CalculationNode const&) const override; private: - ExpCalculationNode(NonnullOwnPtr); - NonnullOwnPtr m_value; + ExpCalculationNode(NonnullRefPtr); + NonnullRefPtr m_value; }; class RoundCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(RoundingStrategy, NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(RoundingStrategy, NonnullRefPtr, NonnullRefPtr); ~RoundCalculationNode(); virtual String to_string() const override; @@ -662,15 +662,15 @@ public: virtual bool equals(CalculationNode const&) const override; private: - RoundCalculationNode(RoundingStrategy, NonnullOwnPtr, NonnullOwnPtr, Optional); + RoundCalculationNode(RoundingStrategy, NonnullRefPtr, NonnullRefPtr, Optional); RoundingStrategy m_strategy; - NonnullOwnPtr m_x; - NonnullOwnPtr m_y; + NonnullRefPtr m_x; + NonnullRefPtr m_y; }; class ModCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr); ~ModCalculationNode(); virtual String to_string() const override; @@ -681,14 +681,14 @@ public: virtual bool equals(CalculationNode const&) const override; private: - ModCalculationNode(NonnullOwnPtr, NonnullOwnPtr, Optional); - NonnullOwnPtr m_x; - NonnullOwnPtr m_y; + ModCalculationNode(NonnullRefPtr, NonnullRefPtr, Optional); + NonnullRefPtr m_x; + NonnullRefPtr m_y; }; class RemCalculationNode final : public CalculationNode { public: - static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullRefPtr create(NonnullRefPtr, NonnullRefPtr); ~RemCalculationNode(); virtual String to_string() const override; @@ -699,9 +699,9 @@ public: virtual bool equals(CalculationNode const&) const override; private: - RemCalculationNode(NonnullOwnPtr, NonnullOwnPtr, Optional); - NonnullOwnPtr m_x; - NonnullOwnPtr m_y; + RemCalculationNode(NonnullRefPtr, NonnullRefPtr, Optional); + NonnullRefPtr m_x; + NonnullRefPtr m_y; }; } diff --git a/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.cpp index 6eed3605290..8d6e9de5584 100644 --- a/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.cpp @@ -20,7 +20,7 @@ String EdgeStyleValue::to_string(SerializationMode mode) const // FIXME: Figure out how to get the proper calculation context here CalculationContext context = {}; - Vector> sum_parts; + Vector> sum_parts; sum_parts.append(NumericCalculationNode::create(Percentage(100), context)); if (offset().is_length()) { sum_parts.append(NegateCalculationNode::create(NumericCalculationNode::create(offset().length(), context))); diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp index ef9db2c2e6f..49d364701b1 100644 --- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp +++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp @@ -116,7 +116,7 @@ static Optional parse_rounding_strategy(Vector return keyword_to_rounding_strategy(maybe_keyword.value()); } -OwnPtr Parser::parse_math_function(Function const& function, CalculationContext const& context) +RefPtr Parser::parse_math_function(Function const& function, CalculationContext const& context) { TokenStream stream { function.value }; auto arguments = parse_a_comma_separated_list_of_component_values(stream); @@ -137,7 +137,7 @@ OwnPtr Parser::parse_math_function(Function const& function, Ca // Variadic function function_generator.append(R"~~~( Optional determined_argument_type; - Vector> parsed_arguments; + Vector> parsed_arguments; parsed_arguments.ensure_capacity(arguments.size()); for (auto& argument : arguments) { @@ -243,7 +243,7 @@ OwnPtr Parser::parse_math_function(Function const& function, Ca } else { // NOTE: This assumes everything not handled above is a calculation node of some kind. parameter_is_calculation = true; - parameter_generator.set("parameter_type", "OwnPtr"_string); + parameter_generator.set("parameter_type", "RefPtr"_string); parameter_generator.set("parse_function", "parse_a_calculation(arguments[argument_index], context)"_string); parameter_generator.set("check_function", " != nullptr"_string); parameter_generator.set("release_function", ".release_nonnull()"_string);