LibWeb: Make StyleComponentValueRule use a Variant

This shrinks its size from 96 bytes to 80. It's now limited by the size
of Token.

Userland/Libraries/LibWeb/CSS/Parser/StyleComponentValueRule.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2020-2021, the SerenityOS developers.
- * Copyright (c) 2021, Sam Atkins <atkinssj@serenityos.org>
+ * Copyright (c) 2021-2022, Sam Atkins <atkinssj@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -20,46 +20,26 @@ class StyleComponentValueRule {
     friend class Parser;
 
 public:
-    enum class ComponentType {
-        Token,
-        Function,
-        Block
-    };
-
     StyleComponentValueRule(Token);
     explicit StyleComponentValueRule(NonnullRefPtr<StyleFunctionRule>);
     explicit StyleComponentValueRule(NonnullRefPtr<StyleBlockRule>);
     ~StyleComponentValueRule();
 
-    bool is_block() const { return m_type == ComponentType::Block; }
-    StyleBlockRule const& block() const
-    {
-        VERIFY(is_block());
-        return *m_block;
-    }
+    bool is_block() const { return m_value.has<NonnullRefPtr<StyleBlockRule>>(); }
+    StyleBlockRule const& block() const { return m_value.get<NonnullRefPtr<StyleBlockRule>>(); }
 
-    bool is_function() const { return m_type == ComponentType::Function; }
-    StyleFunctionRule const& function() const
-    {
-        VERIFY(is_function());
-        return *m_function;
-    }
+    bool is_function() const { return m_value.has<NonnullRefPtr<StyleFunctionRule>>(); }
+    StyleFunctionRule const& function() const { return m_value.get<NonnullRefPtr<StyleFunctionRule>>(); }
 
-    bool is_token() const { return m_type == ComponentType::Token; }
-    bool is(Token::Type type) const
-    {
-        return m_type == ComponentType::Token && m_token.is(type);
-    }
-    Token const& token() const { return m_token; }
-    operator Token() const { return m_token; }
+    bool is_token() const { return m_value.has<Token>(); }
+    bool is(Token::Type type) const { return is_token() && token().is(type); }
+    Token const& token() const { return m_value.get<Token>(); }
+    operator Token() const { return m_value.get<Token>(); }
 
     String to_string() const;
     String to_debug_string() const;
 
 private:
-    ComponentType m_type;
-    Token m_token;
-    RefPtr<StyleFunctionRule> m_function;
-    RefPtr<StyleBlockRule> m_block;
+    Variant<Token, NonnullRefPtr<StyleFunctionRule>, NonnullRefPtr<StyleBlockRule>> m_value;
 };
 }

Userland/Libraries/LibWeb/CSS/Parser/StyleRules.cpp

@@ -37,18 +37,15 @@ StyleBlockRule::StyleBlockRule() = default;
 StyleBlockRule::~StyleBlockRule() = default;
 
 StyleComponentValueRule::StyleComponentValueRule(Token token)
-    : m_type(StyleComponentValueRule::ComponentType::Token)
-    , m_token(token)
+    : m_value(token)
 {
 }
 StyleComponentValueRule::StyleComponentValueRule(NonnullRefPtr<StyleFunctionRule> function)
-    : m_type(StyleComponentValueRule::ComponentType::Function)
-    , m_function(function)
+    : m_value(function)
 {
 }
 StyleComponentValueRule::StyleComponentValueRule(NonnullRefPtr<StyleBlockRule> block)
-    : m_type(StyleComponentValueRule::ComponentType::Block)
-    , m_block(block)
+    : m_value(block)
 {
 }
 StyleComponentValueRule::~StyleComponentValueRule() = default;
@@ -129,38 +126,24 @@ String StyleBlockRule::to_string() const
 
 String StyleComponentValueRule::to_string() const
 {
-    switch (m_type) {
-    case StyleComponentValueRule::ComponentType::Token:
-        return m_token.to_string();
-    case StyleComponentValueRule::ComponentType::Function:
-        return m_function->to_string();
-    case StyleComponentValueRule::ComponentType::Block:
-        return m_block->to_string();
-    default:
-        VERIFY_NOT_REACHED();
-    }
+    return m_value.visit(
+        [](Token const& token) { return token.to_string(); },
+        [](NonnullRefPtr<StyleBlockRule> const& block) { return block->to_string(); },
+        [](NonnullRefPtr<StyleFunctionRule> const& function) { return function->to_string(); });
 }
 
 String StyleComponentValueRule::to_debug_string() const
 {
-    StringBuilder builder;
-
-    switch (m_type) {
-    case ComponentType::Token:
-        builder.append("Token: ");
-        builder.append(m_token.to_debug_string());
-        break;
-    case ComponentType::Function:
-        builder.append("Function: ");
-        builder.append(m_function->to_string());
-        break;
-    case ComponentType::Block:
-        builder.append("Block: ");
-        builder.append(m_block->to_string());
-        break;
-    }
-
-    return builder.to_string();
+    return m_value.visit(
+        [](Token const& token) {
+            return String::formatted("Token: {}", token.to_debug_string());
+        },
+        [](NonnullRefPtr<StyleBlockRule> const& block) {
+            return String::formatted("Function: {}", block->to_string());
+        },
+        [](NonnullRefPtr<StyleFunctionRule> const& function) {
+            return String::formatted("Block: {}", function->to_string());
+        });
 }
 
 String StyleDeclarationRule::to_string() const