feat(css/ast): Make AST intuitive (#6606)

Author: kdy1

crates/swc_css_ast/src/base.rs

@@ -126,13 +126,15 @@ pub enum ComponentValue {
     #[tag("SimpleBlock")]
     SimpleBlock(Box<SimpleBlock>),
 
-    // Block Contents grammar
-    #[tag("DeclarationOrAtRule")]
-    DeclarationOrAtRule(Box<DeclarationOrAtRule>),
-    #[tag("Rule")]
-    Rule(Box<Rule>),
-    #[tag("StyleBlock")]
-    StyleBlock(Box<StyleBlock>),
+    #[tag("AtRule")]
+    AtRule(Box<AtRule>),
+
+    #[tag("QualifiedRule")]
+    QualifiedRule(Box<QualifiedRule>),
+
+    #[tag("ListOfComponentValues")]
+    ListOfComponentValues(Box<ListOfComponentValues>),
+
     #[tag("KeyframeBlock")]
     KeyframeBlock(Box<KeyframeBlock>),
 
@@ -181,6 +183,50 @@ pub enum ComponentValue {
     Declaration(Box<Declaration>),
 }
 
+impl From<StyleBlock> for ComponentValue {
+    #[inline]
+    fn from(block: StyleBlock) -> Self {
+        match block {
+            StyleBlock::AtRule(at_rule) => ComponentValue::AtRule(at_rule),
+            StyleBlock::Declaration(declaration) => ComponentValue::Declaration(declaration),
+            StyleBlock::QualifiedRule(qualified_rule) => {
+                ComponentValue::QualifiedRule(qualified_rule)
+            }
+            StyleBlock::ListOfComponentValues(list_of_component_values) => {
+                ComponentValue::ListOfComponentValues(list_of_component_values)
+            }
+        }
+    }
+}
+
+impl From<DeclarationOrAtRule> for ComponentValue {
+    #[inline]
+    fn from(rule: DeclarationOrAtRule) -> Self {
+        match rule {
+            DeclarationOrAtRule::Declaration(declaration) => {
+                ComponentValue::Declaration(declaration)
+            }
+            DeclarationOrAtRule::AtRule(at_rule) => ComponentValue::AtRule(at_rule),
+            DeclarationOrAtRule::ListOfComponentValues(list_of_component_values) => {
+                ComponentValue::ListOfComponentValues(list_of_component_values)
+            }
+        }
+    }
+}
+
+impl From<Rule> for ComponentValue {
+    #[inline]
+    fn from(rule: Rule) -> Self {
+        match rule {
+            Rule::AtRule(at_rule) => ComponentValue::AtRule(at_rule),
+            Rule::QualifiedRule(qualified_rule) => ComponentValue::QualifiedRule(qualified_rule),
+            Rule::ListOfComponentValues(list_of_component_values) => {
+                ComponentValue::ListOfComponentValues(list_of_component_values)
+            }
+        }
+    }
+}
+
 #[ast_node]
 #[derive(Eq, Hash, Is, EqIgnoreSpan)]
 pub enum DeclarationOrAtRule {

crates/swc_css_codegen/src/lib.rs

@@ -1327,79 +1327,65 @@ where
 
         for (idx, node) in n.value.iter().enumerate() {
             match node {
-                ComponentValue::StyleBlock(_) => {
+                ComponentValue::ListOfComponentValues(_) | ComponentValue::Declaration(_) => {
                     if idx == 0 {
                         formatting_newline!(self);
                     }
 
                     increase_indent!(self);
                 }
-                ComponentValue::Rule(_) | ComponentValue::KeyframeBlock(_) => {
+                ComponentValue::AtRule(_)
+                | ComponentValue::QualifiedRule(_)
+                | ComponentValue::KeyframeBlock(_) => {
                     formatting_newline!(self);
                     increase_indent!(self);
                 }
-                ComponentValue::DeclarationOrAtRule(_) => {
-                    if idx == 0 {
-                        formatting_newline!(self);
-                    }
 
-                    increase_indent!(self);
-                }
                 _ => {}
             }
 
-            emit!(self, node);
+            match node {
+                ComponentValue::ListOfComponentValues(node) => {
+                    emit!(
+                        &mut *self.with_ctx(Ctx {
+                            in_list_of_component_values: true,
+                            ..self.ctx
+                        }),
+                        node
+                    );
+                }
+                _ => {
+                    emit!(self, node);
+                }
+            }
 
             match node {
-                ComponentValue::Rule(_) => {
+                ComponentValue::AtRule(_) | ComponentValue::QualifiedRule(_) => {
                     formatting_newline!(self);
                     decrease_indent!(self);
                 }
-                ComponentValue::StyleBlock(node) => {
-                    match &**node {
-                        StyleBlock::AtRule(_) | StyleBlock::QualifiedRule(_) => {
-                            formatting_newline!(self);
-                        }
-                        StyleBlock::Declaration(_) => {
-                            if idx != len - 1 {
-                                semi!(self);
-                            } else {
-                                formatting_semi!(self);
-                            }
-
-                            formatting_newline!(self);
-                        }
-                        StyleBlock::ListOfComponentValues(_) => {}
+                ComponentValue::Declaration(_) => {
+                    if idx != len - 1 {
+                        semi!(self);
+                    } else {
+                        formatting_semi!(self);
                     }
 
+                    formatting_newline!(self);
+                    decrease_indent!(self);
+                }
+                ComponentValue::ListOfComponentValues(_) => {
                     decrease_indent!(self);
                 }
+
                 ComponentValue::KeyframeBlock(_) => {
                     if idx == len - 1 {
                         formatting_newline!(self);
                     }
 
                     decrease_indent!(self);
                 }
-                ComponentValue::DeclarationOrAtRule(node) => {
-                    match &**node {
-                        DeclarationOrAtRule::AtRule(_) => {
-                            formatting_newline!(self);
-                        }
-                        DeclarationOrAtRule::Declaration(_) => {
-                            if idx != len - 1 {
-                                semi!(self);
-                            } else {
-                                formatting_semi!(self);
-                            }
-
-                            formatting_newline!(self);
-                        }
-                        DeclarationOrAtRule::ListOfComponentValues(_) => {}
-                    }
 
-                    decrease_indent!(self);
-                }
                 _ => {
                     if !self.ctx.in_list_of_component_values && ending == "]" && idx != len - 1 {
                         space!(self);
@@ -1418,9 +1404,9 @@ where
             ComponentValue::Function(n) => emit!(self, n),
             ComponentValue::SimpleBlock(n) => emit!(self, n),
 
-            ComponentValue::StyleBlock(n) => emit!(self, n),
-            ComponentValue::DeclarationOrAtRule(n) => emit!(self, n),
-            ComponentValue::Rule(n) => emit!(self, n),
+            ComponentValue::ListOfComponentValues(n) => emit!(self, n),
+            ComponentValue::QualifiedRule(n) => emit!(self, n),
+            ComponentValue::AtRule(n) => emit!(self, n),
             ComponentValue::KeyframeBlock(n) => emit!(self, n),
 
             ComponentValue::Ident(n) => emit!(self, n),
@@ -1669,7 +1655,7 @@ where
     }
 
     #[emitter]
-    fn emit_frequency_cercentage(&mut self, n: &FrequencyPercentage) -> Result {
+    fn emit_frequency_percentage(&mut self, n: &FrequencyPercentage) -> Result {
         match n {
             FrequencyPercentage::Frequency(n) => emit!(self, n),
             FrequencyPercentage::Percentage(n) => emit!(self, n),