feat(ie-dom): add Doctype node type to DOM #61

Move DOCTYPE from ParseResult workaround to proper DOM node:
- NodeKind::Doctype { name, public_id, system_id } variant
- Document::create_doctype() method
- Tree builder creates Doctype node in handle_initial, appended to
  document root
- Remove doctype_name/public_id/system_id from ParseResult and
  TreeBuilder
- Conformance serializer handles Doctype via normal tree traversal
- parse_html example handles Doctype display
- Tree conformance rate unchanged (42.3%)

Author: thomasnemer

crates/ie-dom/src/document.rs

@@ -62,6 +62,26 @@ impl Document {
         id
     }
 
+    pub fn create_doctype(
+        &mut self,
+        name: &str,
+        public_id: Option<&str>,
+        system_id: Option<&str>,
+    ) -> NodeId {
+        let id = self.nodes.len();
+        self.nodes.push(Node {
+            kind: NodeKind::Doctype {
+                name: name.to_string(),
+                public_id: public_id.map(|s| s.to_string()),
+                system_id: system_id.map(|s| s.to_string()),
+            },
+            parent: None,
+            children: Vec::new(),
+            attributes: HashMap::new(),
+        });
+        id
+    }
+
     // --- Accessors ---
 
     pub fn node(&self, id: NodeId) -> Option<&Node> {

crates/ie-dom/src/node.rs

@@ -15,6 +15,11 @@ pub struct Node {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum NodeKind {
     Document,
+    Doctype {
+        name: String,
+        public_id: Option<String>,
+        system_id: Option<String>,
+    },
     Element(String),
     Text(String),
     Comment(String),

crates/ie-html/examples/parse_html.rs

@@ -35,6 +35,7 @@ fn print_tree(doc: &ie_dom::Document, id: ie_dom::NodeId, indent: usize) {
     let prefix = "| ".repeat(indent);
     match &node.kind {
         ie_dom::NodeKind::Document => println!("{prefix}#document"),
+        ie_dom::NodeKind::Doctype { name, .. } => println!("{prefix}<!DOCTYPE {name}>"),
         ie_dom::NodeKind::Element(name) => {
             let attrs: Vec<String> = node
                 .attributes

crates/ie-html/src/tree_builder.rs

@@ -11,9 +11,6 @@ pub struct ParseResult {
     pub errors: Vec<String>,
     pub style_elements: Vec<String>,
     pub link_stylesheets: Vec<String>,
-    pub doctype_name: Option<String>,
-    pub doctype_public_id: Option<String>,
-    pub doctype_system_id: Option<String>,
 }
 
 /// Top-level parse function. HTML parsing never fails — errors are collected.
@@ -25,9 +22,6 @@ pub fn parse(html: &str) -> ParseResult {
         errors: tb.errors,
         style_elements: tb.style_elements,
         link_stylesheets: tb.link_stylesheets,
-        doctype_name: tb.doctype_name,
-        doctype_public_id: tb.doctype_public_id,
-        doctype_system_id: tb.doctype_system_id,
     }
 }
 
@@ -48,9 +42,6 @@ struct TreeBuilder<'a> {
     link_stylesheets: Vec<String>,
     pending_text: String,
     reprocess_depth: u32,
-    doctype_name: Option<String>,
-    doctype_public_id: Option<String>,
-    doctype_system_id: Option<String>,
     done: bool,
 }
 
@@ -73,9 +64,6 @@ impl<'a> TreeBuilder<'a> {
             link_stylesheets: Vec::new(),
             pending_text: String::new(),
             reprocess_depth: 0,
-            doctype_name: None,
-            doctype_public_id: None,
-            doctype_system_id: None,
             done: false,
         }
     }
@@ -850,9 +838,12 @@ impl<'a> TreeBuilder<'a> {
                 system_id,
                 ..
             } => {
-                self.doctype_name = name;
-                self.doctype_public_id = public_id;
-                self.doctype_system_id = system_id;
+                let doctype_id = self.doc.create_doctype(
+                    name.as_deref().unwrap_or(""),
+                    public_id.as_deref(),
+                    system_id.as_deref(),
+                );
+                let _ = self.doc.append_child(self.doc.root, doctype_id);
                 self.mode = InsertionMode::BeforeHtml;
             }
             _ => {
@@ -2378,6 +2369,7 @@ mod tests {
                 NodeKind::Text(t) => Some(format!("#text:{t}")),
                 NodeKind::Comment(c) => Some(format!("#comment:{c}")),
                 NodeKind::Document => Some("#document".to_string()),
+                NodeKind::Doctype { name, .. } => Some(format!("<!DOCTYPE {name}>")),
             })
             .collect()
     }
@@ -2395,7 +2387,7 @@ mod tests {
         let result = parse_and_check("<!DOCTYPE html><html><head></head><body></body></html>");
         let root = result.document.root;
         let children = child_names(&result, root);
-        assert_eq!(children, vec!["html"]);
+        assert_eq!(children, vec!["<!DOCTYPE html>", "html"]);
 
         let html_id = find_element(&result, "html").unwrap();
         let html_children = child_names(&result, html_id);

crates/ie-html/tests/tree_conformance.rs

@@ -135,26 +135,8 @@ fn parse_test_file(path: &std::path::Path) -> Vec<TreeTest> {
 }
 
 /// Serialize a DOM document to the html5lib tree test format.
-fn serialize_tree_with_doctype(result: &ie_html::ParseResult) -> String {
+fn serialize_tree(doc: &Document) -> String {
     let mut output = String::new();
-    // Output doctype if present
-    if result.doctype_name.is_some()
-        || result.doctype_public_id.is_some()
-        || result.doctype_system_id.is_some()
-    {
-        let name = result.doctype_name.as_deref().unwrap_or("");
-        let public = result.doctype_public_id.as_deref();
-        let system = result.doctype_system_id.as_deref();
-        match (public, system) {
-            (Some(p), Some(s)) => {
-                output.push_str(&format!("| <!DOCTYPE {name} \"{p}\" \"{s}\">\n"))
-            }
-            (Some(p), None) => output.push_str(&format!("| <!DOCTYPE {name} \"{p}\" \"\">\n")),
-            (None, Some(s)) => output.push_str(&format!("| <!DOCTYPE {name} \"\" \"{s}\">\n")),
-            (None, None) => output.push_str(&format!("| <!DOCTYPE {name}>\n")),
-        }
-    }
-    let doc = &result.document;
     let root = doc.root;
     let root_node = doc.node(root).unwrap();
     for &child_id in &root_node.children {
@@ -173,6 +155,22 @@ fn serialize_node(doc: &Document, id: NodeId, depth: usize, output: &mut String)
 
     match &node.kind {
         NodeKind::Document => {}
+        NodeKind::Doctype {
+            name,
+            public_id,
+            system_id,
+        } => match (public_id.as_deref(), system_id.as_deref()) {
+            (Some(p), Some(s)) => {
+                output.push_str(&format!("| {indent}<!DOCTYPE {name} \"{p}\" \"{s}\">\n"))
+            }
+            (Some(p), None) => {
+                output.push_str(&format!("| {indent}<!DOCTYPE {name} \"{p}\" \"\">\n"))
+            }
+            (None, Some(s)) => {
+                output.push_str(&format!("| {indent}<!DOCTYPE {name} \"\" \"{s}\">\n"))
+            }
+            (None, None) => output.push_str(&format!("| {indent}<!DOCTYPE {name}>\n")),
+        },
         NodeKind::Element(name) => {
             output.push_str(&format!("| {indent}<{name}>\n"));
             // Sort attributes alphabetically for consistent comparison
@@ -214,7 +212,7 @@ fn run_test_file(filename: &str) -> (usize, usize, Vec<String>) {
         total += 1;
 
         let result = parse(&test.input);
-        let actual = serialize_tree_with_doctype(&result);
+        let actual = serialize_tree(&result.document);
 
         if actual == test.expected_tree {
             passed += 1;