feat(html): Prepare processing system (#4358)

.gitattributes

@@ -7,6 +7,7 @@
 *.rs    text eol=lf merge=union
 *.js    text eol=lf merge=union
 *.json  text eol=lf merge=union
+*.html  text eol=lf merge=union
 *.debug text eol=lf merge=union
 
 **/tests/**/*.js    linguist-detectable=false

crates/swc_html_ast/src/base.rs

@@ -1,9 +1,101 @@
-use swc_common::{ast_node, Span};
-
-use crate::TokenAndSpan;
+use is_macro::Is;
+use string_enum::StringEnum;
+use swc_atoms::JsWord;
+use swc_common::{ast_node, EqIgnoreSpan, Span};
 
 #[ast_node("Document")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
 pub struct Document {
     pub span: Span,
-    pub children: Vec<TokenAndSpan>,
+    pub mode: DocumentMode,
+    pub children: Vec<Child>,
+}
+
+#[ast_node("DocumentFragment")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct DocumentFragment {
+    pub span: Span,
+    pub children: Vec<Child>,
+}
+
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash, EqIgnoreSpan)]
+pub enum DocumentMode {
+    /// `no-quirks`
+    NoQuirks,
+    /// `limited-quirks`
+    LimitedQuirks,
+    /// `quirks`
+    Quirks,
+}
+
+#[ast_node]
+#[derive(Eq, Hash, Is, EqIgnoreSpan)]
+pub enum Child {
+    #[tag("DocumentType")]
+    DocumentType(DocumentType),
+    #[tag("Element")]
+    Element(Element),
+    #[tag("Text")]
+    Text(Text),
+    #[tag("Comment")]
+    Comment(Comment),
+}
+
+#[ast_node("DocumentType")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct DocumentType {
+    pub span: Span,
+    pub name: Option<JsWord>,
+    pub public_id: Option<JsWord>,
+    pub system_id: Option<JsWord>,
+}
+
+#[derive(StringEnum, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash, EqIgnoreSpan)]
+pub enum Namespace {
+    /// `http://www.w3.org/1999/xhtml`
+    HTML,
+    /// `http://www.w3.org/1998/Math/MathML`
+    MATHML,
+    /// `http://www.w3.org/2000/svg`
+    SVG,
+    /// `http://www.w3.org/1999/xlink`
+    XLINK,
+    /// `http://www.w3.org/XML/1998/namespace`
+    XML,
+    /// `http://www.w3.org/2000/xmlns/`
+    XMLNS,
+}
+
+#[ast_node("Element")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct Element {
+    pub span: Span,
+    pub tag_name: JsWord,
+    pub namespace: Namespace,
+    pub attributes: Vec<Attribute>,
+    pub children: Vec<Child>,
+    /// For child nodes in `<template>`
+    pub content: Option<DocumentFragment>,
+}
+
+#[ast_node("Attribute")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct Attribute {
+    pub span: Span,
+    pub name: JsWord,
+    pub value: Option<JsWord>,
+}
+
+#[ast_node("Text")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct Text {
+    pub span: Span,
+    pub value: JsWord,
+}
+
+#[ast_node("Comment")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct Comment {
+    pub span: Span,
+    pub data: JsWord,
 }

crates/swc_html_ast/src/token.rs

@@ -1,23 +1,24 @@
 use serde::{Deserialize, Serialize};
 use swc_atoms::JsWord;
-use swc_common::{ast_node, Span};
+use swc_common::{ast_node, EqIgnoreSpan, Span};
 
 #[ast_node("TokenAndSpan")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
 pub struct TokenAndSpan {
     pub span: Span,
     pub token: Token,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Attribute {
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, EqIgnoreSpan)]
+pub struct AttributeToken {
     pub name: JsWord,
     pub raw_name: Option<JsWord>,
     pub value: Option<JsWord>,
     // TODO improve me for html entity
     pub raw_value: Option<JsWord>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, EqIgnoreSpan)]
 pub enum Token {
     // TODO raw for bogus doctype
     Doctype {
@@ -49,13 +50,13 @@ pub enum Token {
         tag_name: JsWord,
         raw_tag_name: Option<JsWord>,
         self_closing: bool,
-        attributes: Vec<Attribute>,
+        attributes: Vec<AttributeToken>,
     },
     EndTag {
         tag_name: JsWord,
         raw_tag_name: Option<JsWord>,
         self_closing: bool,
-        attributes: Vec<Attribute>,
+        attributes: Vec<AttributeToken>,
     },
     Comment {
         data: JsWord,

crates/swc_html_codegen/src/lib.rs

@@ -43,6 +43,158 @@ where
         self.emit_list(&n.children, ListFormat::NotDelimited)?;
     }
 
+    #[emitter]
+    fn emit_child(&mut self, n: &Child) -> Result {
+        match n {
+            Child::DocumentType(n) => emit!(self, n),
+            Child::Element(n) => emit!(self, n),
+            Child::Text(n) => emit!(self, n),
+            Child::Comment(n) => emit!(self, n),
+        }
+    }
+
+    #[emitter]
+    fn emit_document_doctype(&mut self, n: &DocumentType) -> Result {
+        let mut doctype = String::new();
+
+        doctype.push('<');
+        doctype.push('!');
+        doctype.push_str("DOCTYPE");
+
+        if let Some(name) = &n.name {
+            doctype.push(' ');
+            doctype.push_str(name);
+        }
+
+        if let Some(public_id) = &n.public_id {
+            doctype.push(' ');
+            doctype.push_str("PUBLIC");
+            doctype.push(' ');
+            doctype.push('"');
+            doctype.push_str(public_id);
+            doctype.push('"');
+
+            if let Some(system_id) = &n.system_id {
+                doctype.push(' ');
+                doctype.push('"');
+                doctype.push_str(system_id);
+                doctype.push('"');
+            }
+        } else if let Some(system_id) = &n.system_id {
+            doctype.push(' ');
+            doctype.push_str("SYSTEM");
+            doctype.push(' ');
+            doctype.push('"');
+            doctype.push_str(system_id);
+            doctype.push('"');
+        }
+
+        doctype.push('>');
+
+        write_raw!(self, n.span, &doctype);
+    }
+
+    #[emitter]
+    fn emit_element(&mut self, n: &Element) -> Result {
+        let mut start_tag = String::new();
+
+        start_tag.push('<');
+        start_tag.push_str(&n.tag_name);
+
+        for attribute in &n.attributes {
+            start_tag.push(' ');
+            start_tag.push_str(&attribute.name);
+
+            if let Some(value) = &attribute.value {
+                start_tag.push('=');
+
+                let quote = if value.contains('"') { '\'' } else { '"' };
+
+                start_tag.push(quote);
+                start_tag.push_str(value);
+                start_tag.push(quote);
+            }
+        }
+
+        start_tag.push('>');
+
+        write_str!(self, n.span, &start_tag);
+
+        let no_children = n.namespace == Namespace::HTML
+            && matches!(
+                &*n.tag_name,
+                "area"
+                    | "base"
+                    | "basefont"
+                    | "bgsound"
+                    | "br"
+                    | "col"
+                    | "embed"
+                    | "frame"
+                    | "hr"
+                    | "img"
+                    | "input"
+                    | "keygen"
+                    | "link"
+                    | "meta"
+                    | "param"
+                    | "source"
+                    | "track"
+                    | "wbr"
+            );
+
+        if no_children {
+            return Ok(());
+        }
+
+        if !n.children.is_empty() {
+            self.emit_list(&n.children, ListFormat::NotDelimited)?;
+        }
+
+        let mut end_tag = String::new();
+
+        end_tag.push('<');
+        end_tag.push('/');
+        end_tag.push_str(&n.tag_name);
+        end_tag.push('>');
+
+        write_str!(self, n.span, &end_tag);
+    }
+
+    #[emitter]
+    fn emit_text(&mut self, n: &Text) -> Result {
+        let mut text = String::new();
+
+        for c in n.value.chars() {
+            match c {
+                '&' => {
+                    text.push_str(&String::from("&amp;"));
+                }
+                '<' => {
+                    text.push_str(&String::from("&lt;"));
+                }
+                '>' => {
+                    text.push_str(&String::from("&gt;"));
+                }
+                '\u{00A0}' => text.push_str(&String::from("&nbsp;")),
+                _ => text.push(c),
+            }
+        }
+
+        write_str!(self, n.span, &text);
+    }
+
+    #[emitter]
+    fn emit_comment(&mut self, n: &Comment) -> Result {
+        let mut comment = String::new();
+
+        comment.push_str("<!--");
+        comment.push_str(&n.data);
+        comment.push_str("-->");
+
+        write_str!(self, n.span, &comment);
+    }
+
     #[emitter]
     fn emit_token_and_span(&mut self, n: &TokenAndSpan) -> Result {
         let span = n.span;
@@ -226,7 +378,7 @@ where
 
                 start_tag.push('>');
 
-                write_str!(self, span, &start_tag);
+                write_raw!(self, span, &start_tag);
             }
             Token::EndTag {
                 tag_name,
@@ -325,19 +477,9 @@ where
     fn write_delim(&mut self, f: ListFormat) -> Result {
         match f & ListFormat::DelimitersMask {
             ListFormat::None => {}
-            ListFormat::CommaDelimited => {
-                write_raw!(self, ",");
-                formatting_space!(self);
-            }
             ListFormat::SpaceDelimited => {
                 space!(self)
             }
-            ListFormat::SemiDelimited => {
-                write_raw!(self, ";")
-            }
-            ListFormat::DotDelimited => {
-                write_raw!(self, ".");
-            }
             _ => unreachable!(),
         }
 

crates/swc_html_codegen/src/list.rs

@@ -26,14 +26,6 @@ add_bitflags!(
     Values {
         NotDelimited: 0,
         SpaceDelimited: 1 << 2,
-        /// There is no delimiter between list items (default).
-        SemiDelimited: 1 << 3,
-        CommaDelimited: 1 << 4,
-        DotDelimited: 1 << 5,
-        DelimitersMask: SpaceDelimited | SemiDelimited | CommaDelimited | DotDelimited,
-    },
-    Values {
-        /// Write a trailing comma (",") if present.
-        AllowTrailingComma: 1 << 6,
+        DelimitersMask: SpaceDelimited,
     },
 );

crates/swc_html_codegen/src/macros.rs

@@ -36,14 +36,6 @@ macro_rules! space {
     }};
 }
 
-macro_rules! formatting_space {
-    ($g:expr) => {{
-        if !$g.config.minify {
-            $g.wr.write_space()?;
-        }
-    }};
-}
-
 // macro_rules! increase_indent {
 //     ($g:expr) => {{
 //         if !$g.config.minify {

crates/swc_html_codegen/tests/fixture.rs

@@ -115,8 +115,13 @@ fn run(input: &Path, minify: bool) {
 struct NormalizeTest;
 
 impl VisitMut for NormalizeTest {
-    fn visit_mut_token_and_span(&mut self, n: &mut TokenAndSpan) {
+    // TODO also investigate problem with empty body (why one empty node?)
+    // TODO fix me, we should normalize only last text node in document due to
+    // parsing html logic or maybe improve AST to allow developer understand it
+    fn visit_mut_text(&mut self, n: &mut Text) {
         n.visit_mut_children_with(self);
+
+        n.value = "".into();
     }
 
     fn visit_mut_span(&mut self, n: &mut Span) {