t-strings · ianjosephwilson · Jun 11, 2026 · Jun 11, 2026 · Jun 11, 2026 · Jun 11, 2026
diff --git a/tdom/parser.py b/tdom/parser.py
diff --git a/tdom/parser_test.py b/tdom/parser_test.py
@@ -2,9 +2,13 @@
 
 import pytest
 
-from .parser import TemplateParser
+from .parser import (
+    AttributeParsingError,
+    ParsingError,
+    TemplateParser,
+)
 from .placeholders import make_placeholder_config
-from .template_utils import TemplateRef
+from .template_utils import PartPosition, TemplateRef
 from .tnodes import (
     TComment,
     TComponent,
@@ -208,17 +212,17 @@ def test_parse_title_unusual():
 
 
 def test_parse_mismatched_tags():
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="Mismatch"):
         _ = TemplateParser.parse(t"<div><span>Mismatched</div></span>")
 
 
-def test_parse_unclosed_tag():
-    with pytest.raises(ValueError):
+def test_parse_unclosed_element():
+    with pytest.raises(ParsingError, match="unclosed tag <div>"):
         _ = TemplateParser.parse(t"<div>Unclosed")
 
 
 def test_parse_unexpected_closing_tag():
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="Unexpected closing tag"):
         _ = TemplateParser.parse(t"Unopened</div>")
 
 
@@ -242,12 +246,12 @@ def test_nested_self_closing_tags():
 
 
 def test_self_closing_tags_unexpected_closing_tag():
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="Unexpected closing tag"):
         _ = TemplateParser.parse(t"<div /></div>")
 
 
 def test_self_closing_void_tags_unexpected_closing_tag():
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="Unexpected closing tag"):
         _ = TemplateParser.parse(t"<input /></input>")
 
 
@@ -338,20 +342,28 @@ def test_spread_attr():
 
 
 def test_templated_attribute_name_error():
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        AttributeParsingError,
+        match="cannot contain interpolations if the value is also interpolated",
+    ):
         attr_name = "some-attr"
         _ = TemplateParser.parse(t'<div {attr_name}="value" />')
 
 
 def test_templated_attribute_name_and_value_error():
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        AttributeParsingError,
+        match="cannot contain interpolations if the value is also interpolated",
+    ):
         attr_name = "some-attr"
         value = "value"
         _ = TemplateParser.parse(t'<div {attr_name}="{value}" />')
 
 
 def test_adjacent_spread_attrs_error():
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        AttributeParsingError, match="must have exactly one interpolation in the name"
+    ):
         attrs1 = {}
         attrs2 = {}
         _ = TemplateParser.parse(t"<div {attrs1}{attrs2} />")
@@ -383,14 +395,16 @@ def test_parse_doctype():
 
 def test_parse_doctype_interpolation_error():
     extra = "SYSTEM"
-    with pytest.raises(ValueError):
+    with pytest.raises(
+        ParsingError, match="Interpolations are not allowed in declarations"
+    ):
         _ = TemplateParser.parse(t"<!DOCTYPE html {extra}>")
 
 
 def test_unsupported_decl_error():
-    with pytest.raises(NotImplementedError):
+    with pytest.raises(ParsingError, match="Only well formed DOCTYPE declarations"):
         _ = TemplateParser.parse(t"<!doctype-alt html500>")  # Unknown declaration
-    with pytest.raises(NotImplementedError):
+    with pytest.raises(ParsingError, match="Only well formed DOCTYPE declarations"):
         _ = TemplateParser.parse(t"<!doctype>")  # missing DTD
 
 
@@ -440,34 +454,51 @@ def test_component_element_invalid_closing_tag():
     def Component():
         pass
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="Mismatched closing tag </div>"):
         _ = TemplateParser.parse(t"<{Component}></div>")
 
 
 def test_component_element_invalid_opening_tag():
     def Component():
         pass
 
-    with pytest.raises(ValueError):
+    # @NOTE: intentional expression
+    with pytest.raises(ParsingError, match="Mismatched closing tag </{Component}>"):
         _ = TemplateParser.parse(t"<div></{Component}>")
 
 
 def test_adjacent_start_component_tag_error():
     def Component():
         pass
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="must have exactly one interpolation"):
         _ = TemplateParser.parse(t"<{Component}{Component}></{Component}>")
 
 
 def test_adjacent_end_component_tag_error():
     def Component():
         pass
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ParsingError, match="must have exactly one interpolation"):
         _ = TemplateParser.parse(t"<{Component}></{Component}{Component}>")
 
 
+def test_unmatched_end_component_tag_error():
+    def Component():
+        pass
+
+    with pytest.raises(ParsingError, match="Unexpected closing tag </{Component}>"):
+        _ = TemplateParser.parse(t"</{Component}>")
+
+
+def test_unclosed_component_tag_error():
+    def Component():
+        pass
+
+    with pytest.raises(ParsingError, match="unclosed tag <{Component}>"):
+        _ = TemplateParser.parse(t"<{Component}>")
+
+
 def test_placeholder_collision_avoidance():
     config = make_placeholder_config()
     # This test is to ensure that our placeholder detection avoids collisions
@@ -487,17 +518,17 @@ def test_placeholder_collision_avoidance():
 
 class TestIncompleteParsing:
     def test_dangling_quotes(self):
-        with pytest.raises(ValueError, match="Parser expects more data"):
+        with pytest.raises(ParsingError, match="Parser expects more data"):
             _ = TemplateParser.parse(t"<div a='")
-        with pytest.raises(ValueError, match="Parser expects more data"):
+        with pytest.raises(ParsingError, match="Parser expects more data"):
             _ = TemplateParser.parse(t'<div a="')
 
     def test_unfinished_attribute(self):
-        with pytest.raises(ValueError, match="Parser expects more data"):
+        with pytest.raises(ParsingError, match="Parser expects more data"):
             _ = TemplateParser.parse(t"<div a=")
 
     def test_placeholder_missing_from_dangling_quote(self):
-        with pytest.raises(ValueError, match="Parser expects more data"):
+        with pytest.raises(ParsingError, match="Parser expects more data"):
             _ = TemplateParser.parse(t'<div a="{None}')
 
 
@@ -602,3 +633,126 @@ def test_extract_with_templated_attr_gt_char(self, Component):
                 strings=("<div>Hello, World!</div>",), i_indexes=()
             ),
         )
+
+
+class TestElementWithAmbiguousSlash:
+    def test_root_unclosed_error(self):
+        with pytest.raises(
+            ParsingError, match="Did you mean to quote the last attribute.*attr[=]root/"
+        ):
+            _ = TemplateParser.parse(t"<div attr=root/>")
+
+    def test_nested_unclosed_error(self):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*attr[=]nested/",
+        ):
+            _ = TemplateParser.parse(t"<div><div attr=nested/></div>")
+
+    def test_double_nested_unclosed_error(self):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*attr[=]nested/",
+        ):
+            _ = TemplateParser.parse(t"<div><div/><div><div attr=nested/></div></div>")
+
+    def test_mismatch_with_element_error(self):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*attr[=]mismatch/",
+        ):
+            _ = TemplateParser.parse(t"<section><div attr=mismatch/></section>")
+
+    def test_mismatch_with_component_error(self):
+        def Comp(children: Template) -> Template:
+            return t""
+
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*attr[=]mismatch/",
+        ):
+            _ = TemplateParser.parse(t"<{Comp}><div attr=mismatch/></{Comp}>")
+
+
+class TestComponentWithAmbiguousSlash:
+    @pytest.fixture
+    def Comp1(self):
+        def _Comp1(children: Template, title: str) -> Template:
+            return children
+
+        return _Comp1
+
+    @pytest.fixture
+    def Comp2(self):
+        def _Comp2(children: Template, title: str) -> Template:
+            return children
+
+        return _Comp2
+
+    @pytest.fixture
+    def Comp3(self):
+        def _Comp3(children: Template, title: str) -> Template:
+            return children
+
+        return _Comp3
+
+    def test_mismatch_with_element_error(self, Comp1):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*title[=]today/",
+        ):
+            _ = TemplateParser.parse(t"<div><{Comp1} title=today/></div>")
+
+    def test_root_unclosed_error(self, Comp1):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*title[=]today/",
+        ):
+            _ = TemplateParser.parse(t"<{Comp1} title=today/>")
+
+    def test_single_nested_unclosed_error(self, Comp1, Comp2):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*title[=]today/",
+        ):
+            _ = TemplateParser.parse(t"<{Comp2}><{Comp1} title=today/></{Comp2}>")
+
+    def test_double_nested_unclosed_error(self, Comp1, Comp2, Comp3):
+        with pytest.raises(
+            ParsingError,
+            match="Did you mean to quote the last attribute.*title[=]today/",
+        ):
+            _ = TemplateParser.parse(
+                t"<{Comp2}><{Comp1}><{Comp3} title=today/></{Comp1}></{Comp2}>"
+            )
+
+
+class TestSourcePosition:
+    def test_tnode_source_position(self):
+        "Check that non-fragments are assigned a source position."
+
+        def PositionComp() -> Template:
+            return t""
+
+        for tnode_type, fragment in (
+            (TElement, t"<span></span>"),
+            (TComment, t"<!--ok-->"),
+            (TDocumentType, t"<!doctype html>"),
+            (TComponent, t"<{PositionComp}></{PositionComp}>"),
+            (TText, t"Just a simple text."),
+        ):
+            tnode = TemplateParser.parse(t"<div>" + fragment + t"</div>")
+            assert (
+                isinstance(tnode, TElement)
+                and tnode.tag == "div"
+                and len(tnode.children) == 1
+            )
+            el = tnode.children[0]
+            assert isinstance(el, tnode_type)
+            assert el.source_pos == PartPosition(index=0, offset=len("<div>"))
+
+    def test_fragment_source_position(self):
+        "Fragments do not have a position right now."
+        root = TemplateParser.parse(t"<div></div><section></section>")
+        assert isinstance(root, TFragment)
+        assert not root.source_pos