feat: Added Rust-style error messages for template errors.

mustache/diagnostic.odin

@@ -0,0 +1,332 @@
+package mustache
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+import "core:terminal/ansi"
+import "core:unicode/utf8"
+
+// line_col returns the 1-indexed line and column for a byte offset in source.
+// Newlines ('\n') separate lines; '\r' is treated as part of '\r\n'. Column is
+// counted in bytes from the start of the line.
+line_col :: proc(source: string, pos_in: int) -> (line: int, col: int) {
+	pos := pos_in
+	if pos < 0 {
+		return 1, 1
+	}
+	if pos > len(source) {
+		pos = len(source)
+	}
+	line = 1
+	col = 1
+	for i := 0; i < pos; i += 1 {
+		if source[i] == '\n' {
+			line += 1
+			col = 1
+		} else {
+			col += 1
+		}
+	}
+	return
+}
+
+// line_text returns the Nth (1-indexed) line of source, without the trailing
+// newline. Returns "" if line is out of range.
+line_text :: proc(source: string, line: int) -> string {
+	if line < 1 {
+		return ""
+	}
+	current := 1
+	start := 0
+	for i := 0; i < len(source); i += 1 {
+		if current == line {
+			end := i
+			for end < len(source) && source[end] != '\n' {
+				end += 1
+			}
+			return source[start:end]
+		}
+		if source[i] == '\n' {
+			current += 1
+			start = i + 1
+		}
+	}
+	if current == line {
+		return source[start:]
+	}
+	return ""
+}
+
+// context_extent returns the byte offset of the start of the line containing
+// pos, plus the byte offsets of the start and end of the mustache tag at pos.
+// Used to underline the offending tag. If pos is not inside a tag, the
+// returned [token_start, token_end) is a single rune at pos.
+context_extent :: proc(
+	source: string,
+	pos_in: int,
+) -> (
+	line_start: int,
+	token_start: int,
+	token_end: int,
+) {
+	pos := pos_in
+	if pos < 0 {
+		return 0, 0, 0
+	}
+	if pos >= len(source) {
+		pos = len(source) - 1
+	}
+	line_start = pos
+	for line_start > 0 && source[line_start - 1] != '\n' {
+		line_start -= 1
+	}
+
+	// Scan forward from line_start for `{{ ... }}` tags. If pos falls inside
+	// any tag's byte range, return that tag's extent.
+	i := line_start
+	for i + 1 < len(source) {
+		if source[i] == '{' && source[i + 1] == '{' {
+			tag_start := i
+			// Find closing }}
+			j := i + 2
+			depth := 1
+			for j + 1 < len(source) && depth > 0 {
+				if source[j] == '{' && source[j + 1] == '{' {
+					depth += 1
+					j += 2
+				} else if source[j] == '}' && source[j + 1] == '}' {
+					depth -= 1
+					j += 2
+				} else {
+					j += 1
+				}
+			}
+			tag_end := j
+			if pos >= tag_start && pos < tag_end {
+				return line_start, tag_start, tag_end
+			}
+			i = tag_end
+		} else {
+			i += 1
+		}
+	}
+
+	// Not inside a tag — underline a single rune at pos.
+	return line_start, pos, pos + 1
+}
+
+// should_colorize returns true if stderr is a TTY and color output is wanted.
+should_colorize :: proc() -> bool {
+	return os.is_tty(os.stderr)
+}
+
+// count_lines returns the number of '\n'-separated lines in source.
+// A trailing newline does not add an extra line.
+count_lines :: proc(source: string) -> int {
+	if len(source) == 0 {
+		return 1
+	}
+	n := 1
+	for c in source {
+		if c == '\n' {
+			n += 1
+		}
+	}
+	// Drop phantom last line if source ends with '\n'.
+	if len(source) > 0 && source[len(source) - 1] == '\n' {
+		n -= 1
+	}
+	return n
+}
+
+// digit_count returns the number of decimal digits in n (min 1).
+digit_count :: proc(n: int) -> int {
+	if n <= 0 {
+		return 1
+	}
+	c := 0
+	x := n
+	for x > 0 {
+		c += 1
+		x /= 10
+	}
+	return c
+}
+
+// display_width returns the number of terminal cells `s` occupies.
+// For ASCII this is byte length; for UTF-8 we count runes (combining
+// marks and wide CJK chars are still approximate).
+display_width :: proc(s: string) -> int {
+	return utf8.rune_count_in_string(s)
+}
+
+// format_error produces a rust-style multi-line diagnostic string.
+//
+//   <msg>
+//    --> <path>:<line>:<col>
+//     |
+//  N | <source line N-2>
+//  N | <source line N-1>
+//  N | <source line N — the error line>
+//     |     ^^^^^^^^^^^ <hint>
+//  N | <source line N+1>
+//  N | <source line N+2>
+//     |
+//
+// `context_before`/`context_after` lines of context are shown around the
+// error line. Line numbers are right-aligned to the width of the largest
+// line number shown.
+format_error :: proc(
+	path: string,
+	source: string,
+	pos: int,
+	msg: string,
+	hint: string = "",
+	context_before: int = 2,
+	context_after: int = 2,
+	colorize: bool = false,
+) -> string {
+	line, col := line_col(source, pos)
+	total_lines := count_lines(source)
+
+	start_line := line - context_before
+	if start_line < 1 {
+		start_line = 1
+	}
+	end_line := line + context_after
+	if end_line > total_lines {
+		end_line = total_lines
+	}
+
+	// Width of the line-number column (right-align).
+	width := digit_count(end_line)
+	if width < 1 {
+		width = 1
+	}
+
+	sb := strings.builder_make(context.temp_allocator)
+	defer strings.builder_destroy(&sb)
+
+	color := colorize
+	red, faint, reset := "", "", ""
+	if color {
+		red = ansi.CSI + ansi.FG_RED + ansi.SGR
+		faint = ansi.CSI + ansi.FAINT + ansi.SGR
+		reset = ansi.CSI + ansi.RESET + ansi.SGR
+	}
+
+	// Header line: message.
+	strings.write_string(&sb, msg)
+	strings.write_byte(&sb, '\n')
+
+	// Location line: "  --> path:line:col" (width spaces + arrow).
+	strings.write_string(&sb, faint)
+	for _ in 0 ..< width {
+		strings.write_byte(&sb, ' ')
+	}
+	strings.write_string(&sb, "--> ")
+	strings.write_string(&sb, reset)
+	strings.write_string(&sb, fmt.tprintf("%s:%d:%d\n", path, line, col))
+
+	// Top gutter line.
+	write_gutter(&sb, width, faint, reset)
+
+	// Caret extent for the error line.
+	_, token_start, token_end := context_extent(source, pos)
+	line_start, _, _ := context_extent(source, pos)
+	caret_start_col := token_start - line_start + 1
+	caret_end_col := token_end - line_start + 1
+	if caret_end_col <= caret_start_col {
+		caret_end_col = caret_start_col + 1
+	}
+
+	// Context lines.
+	for n in start_line ..= end_line {
+		// Line number (right-aligned, faint).
+		num_str := fmt.tprintf("%d", n)
+		strings.write_string(&sb, faint)
+		for _ in 0 ..< width - len(num_str) {
+			strings.write_byte(&sb, ' ')
+		}
+		strings.write_string(&sb, num_str)
+		strings.write_string(&sb, " | ")
+		strings.write_string(&sb, reset)
+
+		strings.write_string(&sb, line_text(source, n))
+		strings.write_byte(&sb, '\n')
+
+		// After the error line, emit the caret row.
+		if n == line {
+			strings.write_string(&sb, faint)
+			for _ in 0 ..< width + 1 {
+				strings.write_byte(&sb, ' ')
+			}
+			strings.write_string(&sb, "| ")
+			strings.write_string(&sb, reset)
+
+			for _ in 1 ..< caret_start_col {
+				strings.write_byte(&sb, ' ')
+			}
+			if color {
+				strings.write_string(&sb, red)
+			}
+			for _ in 0 ..< caret_end_col - caret_start_col {
+				strings.write_byte(&sb, '^')
+			}
+			if color {
+				strings.write_string(&sb, reset)
+			}
+			if hint != "" {
+				strings.write_byte(&sb, ' ')
+				if color {
+					strings.write_string(&sb, faint)
+				}
+				strings.write_string(&sb, hint)
+				if color {
+					strings.write_string(&sb, reset)
+				}
+			}
+			strings.write_byte(&sb, '\n')
+		}
+	}
+
+	// Trailing gutter line for visual closure.
+	write_gutter(&sb, width, faint, reset)
+
+	return strings.to_string(sb)
+}
+
+// write_gutter emits a faint pipe-only gutter line: `<width+1 spaces> |`.
+write_gutter :: proc(sb: ^strings.Builder, width: int, faint: string, reset: string) {
+	strings.write_string(sb, faint)
+	for _ in 0 ..< width + 1 {
+		strings.write_byte(sb, ' ')
+	}
+	strings.write_string(sb, "|")
+	strings.write_string(sb, reset)
+	strings.write_byte(sb, '\n')
+}
+
+// format_render_error dispatches on Render_Error variant and produces a
+// diagnostic for it. Returns "" for nil errors.
+format_render_error :: proc(err: Render_Error, tmpl: Template, colorize: bool = false) -> string {
+	if err == nil {
+		return ""
+	}
+	switch e in err {
+	case Syntax_Error:
+		path := tmpl.path
+		if path == "" {
+			path = "<input>"
+		}
+		return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
+	case Data_Error:
+		path := tmpl.path
+		if path == "" {
+			path = "<input>"
+		}
+		return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
+	}
+	return ""
+}
+

mustache/diagnostic_test.odin

@@ -0,0 +1,576 @@
+#+test
+package mustache
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+// ---------------------------------------------------------------------------
+// line_col / line_text / count_lines / digit_count — primitive helpers
+// ---------------------------------------------------------------------------
+
+@(test)
+test_line_col_basic :: proc(t: ^testing.T) {
+	src := "abc\ndef\nghi"
+	cases := [?]struct {
+		pos:  int,
+		line: int,
+		col:  int,
+	}{{0, 1, 1}, {2, 1, 3}, {3, 1, 4}, {4, 2, 1}, {6, 2, 3}, {7, 2, 4}, {8, 3, 1}}
+	for c in cases {
+		l, col := line_col(src, c.pos)
+		testing.expect(t, l == c.line, fmt.tprintf("pos %d: line %d, want %d", c.pos, l, c.line))
+		testing.expect(t, col == c.col, fmt.tprintf("pos %d: col %d, want %d", c.pos, col, c.col))
+	}
+}
+
+@(test)
+test_line_col_empty :: proc(t: ^testing.T) {
+	l, col := line_col("", 0)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_negative :: proc(t: ^testing.T) {
+	l, col := line_col("abc", -1)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_past_end :: proc(t: ^testing.T) {
+	l, col := line_col("abc", 100)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 4)
+}
+
+@(test)
+test_line_text_first :: proc(t: ^testing.T) {
+	src := "first\nsecond\nthird"
+	testing.expect_value(t, line_text(src, 1), "first")
+	testing.expect_value(t, line_text(src, 2), "second")
+	testing.expect_value(t, line_text(src, 3), "third")
+}
+
+@(test)
+test_line_text_trailing_newline :: proc(t: ^testing.T) {
+	src := "first\nsecond\n"
+	testing.expect_value(t, line_text(src, 1), "first")
+	testing.expect_value(t, line_text(src, 2), "second")
+	testing.expect_value(t, line_text(src, 3), "")
+}
+
+@(test)
+test_line_text_out_of_range :: proc(t: ^testing.T) {
+	testing.expect_value(t, line_text("abc", 5), "")
+	testing.expect_value(t, line_text("abc", 0), "")
+}
+
+@(test)
+test_count_lines :: proc(t: ^testing.T) {
+	testing.expect_value(t, count_lines(""), 1)
+	testing.expect_value(t, count_lines("abc"), 1)
+	testing.expect_value(t, count_lines("a\nb"), 2)
+	testing.expect_value(t, count_lines("a\nb\n"), 2)
+	testing.expect_value(t, count_lines("a\nb\nc"), 3)
+}
+
+@(test)
+test_digit_count :: proc(t: ^testing.T) {
+	testing.expect_value(t, digit_count(0), 1)
+	testing.expect_value(t, digit_count(1), 1)
+	testing.expect_value(t, digit_count(9), 1)
+	testing.expect_value(t, digit_count(10), 2)
+	testing.expect_value(t, digit_count(99), 2)
+	testing.expect_value(t, digit_count(100), 3)
+	testing.expect_value(t, digit_count(-5), 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_error — golden output tests
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_basic :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\n{{bad}}\nline 4\nline 5"
+	out := format_error("p.html", src, 14, "unknown key 'bad'", "", colorize = false)
+	expected := `unknown key 'bad'
+ --> p.html:3:1
+  |
+1 | line 1
+2 | line 2
+3 | {{bad}}
+  | ^^^^^^^
+4 | line 4
+5 | line 5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_with_hint :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\n{{titel}}\nline 4\nline 5"
+	out := format_error(
+		"post.html",
+		src,
+		14,
+		"unknown key 'titel'",
+		"did you mean 'title'?",
+		colorize = false,
+	)
+	expected := `unknown key 'titel'
+ --> post.html:3:1
+  |
+1 | line 1
+2 | line 2
+3 | {{titel}}
+  | ^^^^^^^^^ did you mean 'title'?
+4 | line 4
+5 | line 5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_no_hint_omits_trailing_space :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// Caret line ends immediately after the carets — no trailing space.
+	testing.expect(t, strings.contains(out, "^^^^^^^\n"), out)
+	testing.expect(t, !strings.contains(out, "^^^^^^^ \n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Edge cases — context window clamping
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_first_line_only_after_context :: proc(t: ^testing.T) {
+	src := "{{bad}}\nline 2\nline 3\nline 4\nline 5"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:1:1
+  |
+1 | {{bad}}
+  | ^^^^^^^
+2 | line 2
+3 | line 3
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_last_line_only_before_context :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\nline 3\nline 4\n{{bad}}"
+	out := format_error("p.html", src, 28, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:5:1
+  |
+3 | line 3
+4 | line 4
+5 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_short_source_clamped :: proc(t: ^testing.T) {
+	src := "x\n{{bad}}\ny"
+	out := format_error("p.html", src, 2, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:2:1
+  |
+1 | x
+2 | {{bad}}
+  | ^^^^^^^
+3 | y
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_single_line_source :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:1:1
+  |
+1 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_two_digit_line_numbers :: proc(t: ^testing.T) {
+	// 12-line source; error on line 9. end_line=11 → width=2.
+	src := "l01\nl02\nl03\nl04\nl05\nl06\nl07\nl08\n{{bad}}\nl10\nl11\nl12"
+	// Position of `{{bad}}`: 8 lines of "l0N\n" = 8*4 = 32 bytes.
+	out := format_error("p.html", src, 32, "msg", "", colorize = false)
+	testing.expect(t, strings.contains(out, "  --> p.html:9:1\n"), out)
+	testing.expect(t, strings.contains(out, "   |\n"), out)
+	testing.expect(t, strings.contains(out, " 7 | l07\n"), out)
+	testing.expect(t, strings.contains(out, " 9 | {{bad}}\n"), out)
+	testing.expect(t, strings.contains(out, "11 | l11\n"), out)
+}
+
+@(test)
+test_format_error_three_digit_line_numbers :: proc(t: ^testing.T) {
+	// 102-line source; error on line 100. Width=3 because end_line=102 has 3 digits.
+	parts: [dynamic]string
+	defer delete(parts)
+	for i in 1 ..= 99 {
+		append(&parts, fmt.tprintf("l%03d", i))
+	}
+	append(&parts, "{{bad}}")
+	append(&parts, "l101")
+	append(&parts, "l102")
+	src := strings.join(parts[:], "\n", context.temp_allocator)
+
+	// Find byte position of "{{bad}}": after 99 lines.
+	pos := 0
+	for i in 1 ..= 99 {
+		pos += len(parts[i - 1]) + 1
+	}
+
+	out := format_error("p.html", src, pos, "msg", "", colorize = false)
+	testing.expect(t, strings.contains(out, "   --> p.html:100:1\n"), out)
+	testing.expect(t, strings.contains(out, "    |\n"), out)
+	testing.expect(t, strings.contains(out, " 98 | l098\n"), out)
+	testing.expect(t, strings.contains(out, "100 | {{bad}}\n"), out)
+	testing.expect(t, strings.contains(out, "102 | l102\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Caret position
+// ---------------------------------------------------------------------------
+
+@(test)
+test_caret_at_column_1 :: proc(t: ^testing.T) {
+	src := "{{bad}} at start"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// Caret line should start with "^" right after "| " (no leading spaces).
+	testing.expect(t, strings.contains(out, "  | ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_at_column_N :: proc(t: ^testing.T) {
+	src := "    {{bad}}"
+	// pos=4 is the first '{'. Line 1, col 5.
+	out := format_error("p.html", src, 4, "msg", "", colorize = false)
+	// 4 leading spaces, then 7 carets.
+	testing.expect(t, strings.contains(out, "  |     ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_width_matches_token :: proc(t: ^testing.T) {
+	src := "{{x}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// {{x}} is 5 chars wide.
+	testing.expect(t, strings.contains(out, "  | ^^^^^\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Context count
+// ---------------------------------------------------------------------------
+
+@(test)
+test_context_before_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 0,
+		context_after = 1,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+4 | {{bad}}
+  | ^^^^^^^
+5 | l5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_after_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 1,
+		context_after = 0,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+3 | l3
+4 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_both_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 0,
+		context_after = 0,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+4 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+// ---------------------------------------------------------------------------
+// Gutter/alignment
+// ---------------------------------------------------------------------------
+
+@(test)
+test_gutter_pipes_align_with_source_pipe :: proc(t: ^testing.T) {
+	src := "l1\n{{bad}}\nl3"
+	out := format_error("p.html", src, 3, "msg", "", colorize = false)
+	// All "|" characters should appear at the same column.
+	// For width=1: source line is "N | ...", so "|" at col 2.
+	// Empty gutter is "  |" (width+1 spaces + "|"), so "|" at col 2.
+	lines := strings.split(out, "\n", context.temp_allocator)
+	defer delete(lines)
+	pipe_col := -1
+	for line in lines {
+		idx := strings.index(line, "|")
+		if idx < 0 {
+			continue
+		}
+		if pipe_col < 0 {
+			pipe_col = idx
+		} else {
+			testing.expect_value(t, idx, pipe_col)
+		}
+	}
+}
+
+@(test)
+test_arrow_points_at_pipe :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// For width=1: arrow line is " --> ..." so ">" at col 3.
+	// Pipe lines are "  |" so "|" at col 2.
+	lines := strings.split(out, "\n", context.temp_allocator)
+	defer delete(lines)
+
+	pipe_col := -1
+	for line in lines {
+		idx := strings.index(line, "|")
+		if idx >= 0 {
+			pipe_col = idx
+			break
+		}
+	}
+	testing.expect(t, pipe_col >= 0, "expected pipe in output")
+
+	// Find the arrow line specifically and verify its ">" column.
+	arrow_col := -1
+	for line in lines {
+		idx := strings.index(line, "-->")
+		if idx >= 0 {
+			arrow_col = idx + 2 // ">" is the last char of "-->"
+			break
+		}
+	}
+	testing.expect(t, arrow_col >= 0, "expected --> in output")
+	testing.expect_value(t, arrow_col, pipe_col + 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_render_error — dispatch
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_render_error_dispatch :: proc(t: ^testing.T) {
+	src := "{{#unclosed}}\ncontent"
+	tmpl, parse_err := parse(src, "test.html")
+	testing.expect(t, parse_err != nil, "should fail to parse unclosed section")
+	if parse_err == nil {
+		return
+	}
+
+	#partial switch e in parse_err {
+	case Syntax_Error:
+		out := format_error("test.html", src, e.pos, e.msg, colorize = false)
+		testing.expect(t, strings.contains(out, "unclosed section"), out)
+		testing.expect(t, strings.contains(out, "test.html:"), out)
+	}
+}
+
+@(test)
+test_diagnostic_for_pipe_error :: proc(t: ^testing.T) {
+	src := "{{#name | group_by year}}x{{/name}}"
+	tmpl, perr := parse(src, "test.html")
+	testing.expect(t, perr == nil, "should parse")
+	if perr != nil {
+		return
+	}
+	defer delete_template(&tmpl)
+
+	Data :: struct {
+		name: string,
+	}
+	_, rerr := render(tmpl, Data{name = "hello"})
+	testing.expect(t, rerr != nil, "should fail to render")
+	if rerr == nil {
+		return
+	}
+
+	out := format_render_error(rerr, tmpl, colorize = false)
+	testing.expect(t, strings.contains(out, "group_by expects a list"), out)
+	testing.expect(t, strings.contains(out, "test.html:"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Parser error messages preserve double braces in tag syntax
+// ---------------------------------------------------------------------------
+
+@(test)
+test_parse_error_expected_got_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#content}}body{{/cotent}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{/content}}"),
+			fmt.tprintf("msg should contain literal {{/content}}, got %q", e.msg),
+		)
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{/cotent}}"),
+			fmt.tprintf("msg should contain literal {{/cotent}}, got %q", e.msg),
+		)
+	}
+}
+
+@(test)
+test_parse_error_unclosed_section_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#content}}body"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{#content}}"),
+			fmt.tprintf("msg should contain literal {{#content}}, got %q", e.msg),
+		)
+	}
+}
+
+@(test)
+test_parse_error_unexpected_close_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "text{{/content}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{/content}}"),
+			fmt.tprintf("msg should contain literal {{/content}}, got %q", e.msg),
+		)
+	}
+}
+
+@(test)
+test_parse_error_pipe_in_close_tag_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#posts | group_by year}}x{{/posts | group_by year}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{/"),
+			fmt.tprintf("msg should contain literal '{{/', got %q", e.msg),
+		)
+	}
+}
+
+@(test)
+test_parse_error_pipe_parse_in_section_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#posts |}}x{{/posts}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{#"),
+			fmt.tprintf("msg should contain literal '{{#', got %q", e.msg),
+		)
+	}
+}
+
+@(test)
+test_parse_error_pipe_parse_in_inverted_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{^posts |}}x{{/posts}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	#partial switch e in err {
+	case Syntax_Error:
+		testing.expect(
+			t,
+			strings.contains(e.msg, "{{^"),
+			fmt.tprintf("msg should contain literal '{{^', got %q", e.msg),
+		)
+	}
+}
+

mustache/mustache.odin

@@ -13,6 +13,7 @@ Syntax_Error :: struct {
 	msg: string,
 	pos: int,
 }
+
 Data_Error :: struct {
 	msg: string,
 	pos: int,
@@ -535,7 +536,7 @@ render_nodes :: proc(
 
 		case .Variable:
 			val := resolve_name(node.key, ctx[:])
-			if val ==  nil {
+			if val == nil {
 				warn_unknown_key(current, ctx[:], node)
 			}
 			if len(node.filters) > 0 {