Ignore the form element pointer throughout template contents

The form element pointer is deliberately not used inside template
contents, but the conditions expressing that only tested the stack of
open elements.  A fragment parse whose context element is a template
element produces template contents without a template element on that
stack, so a nested <form> was dropped there.

The standard now defines "parsing template contents", which also covers
that case, and uses it for the <form> start and end tags and for form
association (whatwg/html#12911).  It also
changed the "in table" <form> start tag to insert the element while
parsing template contents, skipping only the pointer assignment, rather
than dropping it, and requires there to be no fragment context element
for form association.  Do the same.

This fixes three template.dat tests that now live in WPT
(html/syntax/parsing/resources).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Anders Kaseorg <andersk@mit.edu>

Author: andersk

html5ever/src/tree_builder/mod.rs

@@ -1119,6 +1119,16 @@ where
             .any(|elem| self.html_elem_named(elem, name.clone()))
     }
 
+    /// <https://html.spec.whatwg.org/multipage/#parsing-template-contents>
+    fn parsing_template_contents(&self) -> bool {
+        self.in_html_elem_named(local_name!("template"))
+            || self
+                .context_elem
+                .borrow()
+                .as_ref()
+                .is_some_and(|elem| self.html_elem_named(elem, local_name!("template")))
+    }
+
     fn current_node_named(&self, name: LocalName) -> bool {
         self.html_elem_named(&self.current_node(), name)
     }
@@ -1385,7 +1395,8 @@ where
         let qname = QualName::new(None, ns, name);
         let form_is_associatable = form_associatable(qname.expanded())
             && self.form_elem.borrow().is_some()
-            && !self.in_html_elem_named(local_name!("template"))
+            && !self.parsing_template_contents()
+            && !self.is_fragment()
             && !(listed(qname.expanded())
                 && attrs
                     .iter()

html5ever/src/tree_builder/rules.rs

@@ -541,14 +541,12 @@ where
                 },
 
                 Token::Tag(tag @ tag!(<form>)) => {
-                    if self.form_elem.borrow().is_some()
-                        && !self.in_html_elem_named(local_name!("template"))
-                    {
+                    if self.form_elem.borrow().is_some() && !self.parsing_template_contents() {
                         self.sink.parse_error(Borrowed("nested forms"));
                     } else {
                         self.close_p_element_in_button_scope();
                         let elem = self.insert_element_for(tag);
-                        if !self.in_html_elem_named(local_name!("template")) {
+                        if !self.parsing_template_contents() {
                             *self.form_elem.borrow_mut() = Some(elem);
                         }
                     }
@@ -630,7 +628,7 @@ where
                 },
 
                 Token::Tag(tag!(</form>)) => {
-                    if !self.in_html_elem_named(local_name!("template")) {
+                    if !self.parsing_template_contents() {
                         let Some(node) = self.form_elem.take() else {
                             self.sink
                                 .parse_error(Borrowed("Null form element pointer on </form>"));
@@ -1116,10 +1114,12 @@ where
 
                 Token::Tag(tag @ tag!(<form>)) => {
                     self.unexpected(&tag);
-                    if !self.in_html_elem_named(local_name!("template"))
-                        && self.form_elem.borrow().is_none()
-                    {
-                        *self.form_elem.borrow_mut() = Some(self.insert_and_pop_element_for(tag));
+                    let parsing_template_contents = self.parsing_template_contents();
+                    if self.form_elem.borrow().is_none() || parsing_template_contents {
+                        let elem = self.insert_and_pop_element_for(tag);
+                        if !parsing_template_contents {
+                            *self.form_elem.borrow_mut() = Some(elem);
+                        }
                     }
                     ProcessResult::Done
                 },

rcdom/tests/html-driver.rs

@@ -3,6 +3,48 @@ use html5ever::serialize;
 use html5ever::tendril::TendrilSink;
 use markup5ever_rcdom::{RcDom, SerializableHandle};
 
+#[test]
+fn form_element_pointer_ignored_in_template_contents() {
+    fn serialize_children(node: markup5ever_rcdom::Handle) -> String {
+        let mut serialized = Vec::new();
+        let node: SerializableHandle = node.into();
+        serialize::serialize(&mut serialized, &node, Default::default()).unwrap();
+        String::from_utf8(serialized).unwrap()
+    }
+
+    // A form start tag in a table in template contents inserts a form
+    let dom = driver::parse_document(RcDom::default(), Default::default())
+        .one("<template><table><form></table></template>");
+    let html = dom.document.children.borrow()[0].clone();
+    let head = html.children.borrow()[0].clone();
+    let template = head.children.borrow()[0].clone();
+    let markup5ever_rcdom::NodeData::Element {
+        ref template_contents,
+        ..
+    } = template.data
+    else {
+        panic!("expected a template element");
+    };
+    let contents = template_contents.borrow().clone().unwrap();
+    assert_eq!(serialize_children(contents), "<table><form></form></table>");
+
+    // When fragment parsing with a template context, nested forms are not dropped
+    let dom = driver::parse_fragment(
+        RcDom::default(),
+        Default::default(),
+        html5ever::QualName::new(
+            None,
+            html5ever::ns!(html),
+            html5ever::local_name!("template"),
+        ),
+        vec![],
+        true,
+    )
+    .one("<form><form>");
+    let html = dom.document.children.borrow()[0].clone();
+    assert_eq!(serialize_children(html), "<form><form></form></form>");
+}
+
 #[test]
 fn from_utf8() {
     let dom = driver::parse_document(RcDom::default(), Default::default())