gofront 1.7.0 → 1.9.0

package/src/parser/expressions.js

@@ -1,6 +1,6 @@
 // Parser expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Binary operator precedence (higher = binds tighter, matching Go spec)
 const PREC = {
@@ -97,6 +97,18 @@ function _isDisallowedInTypeArgs(tt) {
 	return DISALLOWED_IN_TYPE_ARGS.has(tt);
 }
 
+// `[T]` followed by `(` or a composite literal's `{` is an instantiation.  A
+// `{` after the condition of if/for/switch opens the block (`if v == s[i] {`).
+function _opensArgs(after, noCompLit) {
+	return after.type === T.LPAREN || (after.type === T.LBRACE && !noCompLit);
+}
+
+function _isCallParen(src, i, braces) {
+	return (
+		src[i].type === T.LPAREN && braces === 0 && src[i - 1]?.type === T.IDENT
+	);
+}
+
 function _isTypeIntroducerToken(tt) {
 	return (
 		tt === T.STAR ||
@@ -108,9 +120,9 @@ function _isTypeIntroducerToken(tt) {
 }
 
 export const expressionParserMethods = {
-	parseExprList() {
-		const exprs = [this.parseExpr()];
-		while (this.match(T.COMMA)) exprs.push(this.parseExpr());
+	parseExprList(noCompLit = false) {
+		const exprs = [this.parseExpr(0, noCompLit)];
+		while (this.match(T.COMMA)) exprs.push(this.parseExpr(0, noCompLit));
 		return exprs;
 	},
 
@@ -132,7 +144,13 @@ export const expressionParserMethods = {
 		const t = this.peek();
 		if (UNARY_OPS.has(t.type)) {
 			const op = this.advance().value;
-			return { kind: "UnaryExpr", op, operand: this.parseUnary(noCompLit) };
+			return {
+				kind: "UnaryExpr",
+				op,
+				operand: this.parseUnary(noCompLit),
+				_line: t.line,
+				_col: t.col,
+			};
 		}
 		if (t.type === T.AWAIT) {
 			this.advance();
@@ -166,7 +184,21 @@ export const expressionParserMethods = {
 				}
 			} else if (t.type === T.LBRACKET) {
 				// Check if this looks like generic type args: Ident[Type](...)  or Ident[Type]{...}
-				if (expr.kind === "Ident" && this.looksLikeTypeArgList()) {
+				// `pkg.F[int](x)` / `pkg.T[X]{...}` instantiate through a qualifier.
+				const nameLike =
+					expr.kind === "Ident" ||
+					(expr.kind === "SelectorExpr" && expr.expr.kind === "Ident");
+				const plainArgs = nameLike && this.looksLikeTypeArgList(noCompLit);
+				const literalArgs =
+					nameLike && !plainArgs ? this.tryParseTypeLiteralArgs() : null;
+				if (literalArgs) {
+					expr = {
+						kind: "InstantiationExpr",
+						expr,
+						typeArgs: literalArgs,
+						_line: expr._line,
+					};
+				} else if (plainArgs) {
 					this.advance(); // consume [
 					const typeArgs = [this.parseType()];
 					while (this.match(T.COMMA)) typeArgs.push(this.parseType());
@@ -222,15 +254,59 @@ export const expressionParserMethods = {
 		);
 	},
 
+	// `Id[[]int, int]`, `slices.Sort[map[string]int]`: type arguments that are
+	// type literals.  Returns the parsed type list, or null (position restored)
+	// when the brackets hold an index expression such as `a[[]int{1}[0]]`.
+	tryParseTypeLiteralArgs() {
+		const first = this.peek2()?.type;
+		const startsLiteral =
+			first === T.LBRACKET || first === T.MAP || first === T.FUNC;
+		// `*T` could be a dereference in an index, but an index has no comma.
+		if (!startsLiteral && !(first === T.STAR || this._hasTopLevelComma()))
+			return null;
+		const start = this.pos;
+		try {
+			this.expect(T.LBRACKET);
+			const typeArgs = [this.parseType()];
+			while (this.match(T.COMMA)) typeArgs.push(this.parseType());
+			this.expect(T.RBRACKET);
+			if (!startsLiteral && typeArgs.length < 2) throw new Error("not types");
+			// `a[foo, bar]` is not an instantiation: names alone need a literal.
+			if (!startsLiteral && typeArgs.every((a) => a.kind === "TypeName"))
+				throw new Error("not type literals");
+			return typeArgs;
+		} catch {
+			this.pos = start;
+			return null;
+		}
+	},
+
+	// Whether the bracket pair at the current `[` contains a comma outside any
+	// nested brackets, parentheses or braces.
+	_hasTopLevelComma() {
+		let depth = 0;
+		for (let i = this.pos; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACKET || tt === T.LPAREN || tt === T.LBRACE) depth++;
+			else if (tt === T.RBRACKET || tt === T.RPAREN || tt === T.RBRACE) {
+				depth--;
+				if (depth === 0) return false;
+			} else if (tt === T.COMMA && depth === 1) return true;
+			else if (tt === T.EOF) return false;
+		}
+		return false;
+	},
+
 	// Lookahead: does the [ ... ] after an Ident look like generic type args?
 	// Returns true if: only type-like tokens inside brackets, AND followed by a valid continuation
-	looksLikeTypeArgList() {
+	looksLikeTypeArgList(noCompLit = false) {
 		let i = this.pos + 1; // skip [
 		const src = this.tokens;
 		let depth = 1;
 		let hasComma = false;
 		let hasTypeKeyword = false;
 		let hasUpperIdent = false;
+		let braces = 0;
 		while (i < src.length && depth > 0) {
 			const tt = src[i].type;
 			if (tt === T.LBRACKET) {
@@ -241,9 +317,18 @@ export const expressionParserMethods = {
 			if (tt === T.RBRACKET) {
 				depth--;
 				if (depth === 0) break;
+				// `a[i].F` selects from an index result: a value, never a type.
+				if (src[i + 1]?.type === T.DOT) return false;
 				i++;
 				continue;
 			}
+			// `k.(int)` is a type assertion on a value: an index expression
+			if (tt === T.DOT && src[i + 1]?.type === T.LPAREN) return false;
+			// `uint(u)` / `f(x)`: a call or conversion is a value (a method
+			// signature inside `interface{ M() }` is the only type that has one).
+			if (tt === T.LBRACE) braces++;
+			else if (tt === T.RBRACE) braces--;
+			else if (_isCallParen(src, i, braces)) return false;
 			// Reject literals — it's an index expression
 			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
 			// Reject binary operators that wouldn't appear in type args
@@ -268,7 +353,7 @@ export const expressionParserMethods = {
 		const after = src[i + 1];
 		if (!after) return false;
 		// Call or composite lit — always valid as type args
-		if (after.type === T.LPAREN || after.type === T.LBRACE) return true;
+		if (_opensArgs(after, noCompLit)) return true;
 		// Function value in argument list: Identity[int], 99) — only if clearly a type
 		if (after.type === T.COMMA || after.type === T.RPAREN) {
 			return hasComma || hasTypeKeyword || hasUpperIdent;
@@ -294,17 +379,15 @@ export const expressionParserMethods = {
 					(t.type === T.MAP || isSliceOrArrayType) &&
 					!this.looksLikeCompositeLitArg()
 				) {
+					const start = this.pos;
 					const typeNode = this.parseType();
-					// []byte(s) / []rune(s) used as a call argument — it's a type conversion
+					// `[]byte(s)` / `[]int(nil)` is a conversion: an ordinary
+					// operand that may be compared, spread or selected from.
 					if (this.check(T.LPAREN)) {
-						this.advance();
-						const convExpr = this.parseExpr();
-						this.expect(T.RPAREN);
-						args.push({
-							kind: "TypeConversion",
-							targetType: typeNode,
-							expr: convExpr,
-						});
+						this.pos = start;
+						const arg = this.parseExpr();
+						if (this.match(T.ELLIPSIS)) arg._spread = true;
+						args.push(arg);
 					} else {
 						args.push({ kind: "TypeExpr", type: typeNode });
 					}
@@ -369,7 +452,16 @@ export const expressionParserMethods = {
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
 			// Implicit composite literal: {X: 1} inside []Point{{X:1}} or map[string]Point{"a": {X:1}}
 			if (this.check(T.LBRACE)) {
-				elems.push(this.parseCompositeLit(null)); // null typeExpr = inferred
+				const lit = this.parseCompositeLit(null); // null typeExpr = inferred
+				if (this.match(T.COLON)) {
+					// Elided key type: map[P]int{{1}: 2}
+					const val = this.check(T.LBRACE)
+						? this.parseCompositeLit(null)
+						: this.parseExpr();
+					elems.push({ kind: "KeyValueExpr", key: lit, value: val });
+				} else {
+					elems.push(lit);
+				}
 			} else {
 				const first = this.parseExpr();
 				if (this.match(T.COLON)) {

package/src/parser/index.js

@@ -17,7 +17,7 @@
 //   CallExpr, SelectorExpr, IndexExpr, SliceExpr
 //   CompositeLit, KeyValueExpr, FuncLit, AwaitExpr
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 import { declarationParseMethods } from "./declarations.js";
 import { expressionParserMethods } from "./expressions.js";
 import { statementParserMethods } from "./statements.js";
@@ -131,6 +131,7 @@ export class Parser {
 			decls,
 			target: this.tokens?.target ?? null,
 			_targetDirective: this.tokens?.targetDirective ?? null,
+			_embedDirectives: this.tokens?.embedDirectives ?? [],
 			_filename: this.filename,
 			_source: this.source,
 		};

package/src/parser/statements.js

@@ -1,6 +1,6 @@
 // Parser statement methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Method-name dispatch for pure-delegation cases in _parseStmt.
 const PARSE_STMT_DELEGATE = {
@@ -24,6 +24,7 @@ const ASSIGN_OPS = new Set([
 	T.PERCENT_ASSIGN,
 	T.AMP_ASSIGN,
 	T.PIPE_ASSIGN,
+	T.AND_NOT_ASSIGN,
 	T.CARET_ASSIGN,
 	T.LSHIFT_ASSIGN,
 	T.RSHIFT_ASSIGN,
@@ -78,6 +79,13 @@ export const statementParserMethods = {
 				this.advance();
 				this.semi();
 				return { kind: "BranchStmt", keyword: "fallthrough" };
+			case T.GOTO: {
+				// Parsed so the checker can reject it with a targeted message.
+				this.advance();
+				const label = this.expect(T.IDENT).value;
+				this.semi();
+				return { kind: "BranchStmt", keyword: "goto", label };
+			}
 			case T.GO:
 				return this.err("goroutines are not supported in GoFront");
 			case T.SELECT:
@@ -88,7 +96,12 @@ export const statementParserMethods = {
 				if (this.check2(T.COLON)) {
 					const label = this.advance().value;
 					this.advance(); // consume COLON
-					return { kind: "LabeledStmt", label, body: this.parseStmt() };
+					// A label may precede the end of a block: the statement is empty.
+					const body =
+						this.check(T.RBRACE) || this.check(T.CASE) || this.check(T.DEFAULT)
+							? { kind: "Block", stmts: [] }
+							: this.parseStmt();
+					return { kind: "LabeledStmt", label, body };
 				}
 				return this.parseSimpleStmt();
 			default:
@@ -150,27 +163,30 @@ export const statementParserMethods = {
 			};
 		}
 
-		const first = this.parseSimpleStmtRaw(true);
-
-		if (this.check(T.LBRACE)) {
-			// for k, v := range expr { }  — range stmt ends right before {
-			if (this.isRangeStmt(first)) {
+		let first = null;
+		if (!this.check(T.SEMICOLON)) {
+			first = this.parseSimpleStmtRaw(true);
+
+			if (this.check(T.LBRACE)) {
+				// for k, v := range expr { }  — range stmt ends right before {
+				if (this.isRangeStmt(first)) {
+					return {
+						kind: "ForStmt",
+						init: first,
+						cond: null,
+						post: null,
+						body: this.parseBlock(),
+					};
+				}
+				// for cond { }
 				return {
 					kind: "ForStmt",
-					init: first,
-					cond: null,
+					init: null,
+					cond: this.stmtToExpr(first),
 					post: null,
 					body: this.parseBlock(),
 				};
 			}
-			// for cond { }
-			return {
-				kind: "ForStmt",
-				init: null,
-				cond: this.stmtToExpr(first),
-				post: null,
-				body: this.parseBlock(),
-			};
 		}
 
 		this.expect(T.SEMICOLON);
@@ -180,7 +196,7 @@ export const statementParserMethods = {
 		if (!this.check(T.SEMICOLON)) cond = this.parseExpr(0, true);
 		this.expect(T.SEMICOLON);
 		let post = null;
-		if (!this.check(T.LBRACE)) post = this.parseSimpleStmtRaw();
+		if (!this.check(T.LBRACE)) post = this.parseSimpleStmtRaw(true);
 		const body = this.parseBlock();
 		return { kind: "ForStmt", init: first, cond, post, body };
 	},
@@ -290,9 +306,9 @@ export const statementParserMethods = {
 		// a, b, c := ...  or  x, y = ...
 		if (t.type === T.COMMA) {
 			const lhs = [first];
-			while (this.match(T.COMMA)) lhs.push(this.parseExpr());
+			while (this.match(T.COMMA)) lhs.push(this.parseExpr(0, noCompLit));
 			const op = this.advance(); // := or =
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			if (op.type === T.DEFINE) return { kind: "DefineStmt", lhs, rhs };
 			return { kind: "AssignStmt", lhs, op: "=", rhs };
 		}
@@ -300,14 +316,14 @@ export const statementParserMethods = {
 		// x := expr
 		if (t.type === T.DEFINE) {
 			this.advance();
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			return { kind: "DefineStmt", lhs: [first], rhs };
 		}
 
 		// x = expr  or  x += expr  etc.
 		if (ASSIGN_OPS.has(t.type)) {
 			const op = this.advance().value;
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			return { kind: "AssignStmt", lhs: [first], op, rhs };
 		}
 

package/src/{templ-parser.js → parser/templ.js}

@@ -10,15 +10,33 @@
 //   TemplText   { kind, value }
 //   TemplExpr   { kind, tokens }          ← raw Go token array
 //   TemplComponent { kind, tokens }       ← raw Go token array for call
-//   TemplChildren  { kind }
+//   TemplChildren  { kind, name }         ← `{ name... }`, name of a variadic slot
 //   TemplIf     { kind, condTokens, then: TemplNode[], else_: TemplNode[] | null }
 //   TemplFor    { kind, stmtTokens, body: TemplNode[] }
 //   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
 //   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+//               (a `case a, b:` also carries `exprs`, one expression per value)
+//
+// Go expressions embedded in templ (`{ expr }`, attribute values, `if`
+// conditions, `switch` and `case` expressions, `@Comp(...)` calls) and `for`
+// headers are also parsed here, so the code generator never runs the parser.
+// The results sit on the node as non-enumerable properties (the generic AST
+// walkers in rename/lowering visit enumerable keys only, and these ASTs have
+// no type information):
+//   expr       Expression AST, or null when there are no tokens to parse
+//   exprError  The ParseError a malformed expression raised. The parser keeps
+//              it instead of throwing, so the error still surfaces when the
+//              code generator reads the node (after type-checking), as before
+//   raw        TemplComponent only: `@templ.Raw(arg)`; `expr` is then `arg`
+//   forStmt    TemplFor only: the parsed ForStmt, or null when the header does
+//              not parse as a Go `for` clause
+//   forError   TemplFor only: the ParseError the header raised (kept, like
+//              exprError, for the code generator to throw)
+//   attr.expr / attr.exprError on `expr` and `cond-bool` attributes
 
-import { Parser } from "./parser/index.js";
-import { TT } from "./templ-lexer.js";
-import { T } from "./tokens.js";
+import { TT } from "../lexer/templ-lexer.js";
+import { T, Token } from "../lexer/tokens.js";
+import { Parser } from "./index.js";
 
 const VOID_ELEMENTS = new Set([
 	"area",
@@ -37,6 +55,123 @@ const VOID_ELEMENTS = new Set([
 	"wbr",
 ]);
 
+function attach(node, props) {
+	for (const [name, value] of Object.entries(props)) {
+		Object.defineProperty(node, name, {
+			value,
+			enumerable: false,
+			writable: true,
+			configurable: true,
+		});
+	}
+	return node;
+}
+
+// Parses `tokens` as one Go expression, ending at a synthetic EOF token.
+function parseExprTokens(tokens, allowEmpty = true) {
+	if (allowEmpty && (!tokens || tokens.length === 0)) return { expr: null };
+	try {
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...tokens, eofTok]);
+		const expr = p.parseExpr();
+		while (p.check(T.SEMICOLON)) p.advance();
+		if (!p.check(T.EOF))
+			p.err(`unexpected '${p.peek().value}' after expression`);
+		return { expr };
+	} catch (exprError) {
+		return { expr: null, exprError };
+	}
+}
+
+// Parses `tokens` as a comma-separated expression list (`case 1, 2:`). `expr`
+// and `exprError` describe the first expression (or the first error); `exprs`
+// holds every parsed expression.
+function parseExprListTokens(tokens) {
+	if (!tokens || tokens.length === 0) return { expr: null };
+	const parts = [[]];
+	let depth = 0;
+	for (const t of trimSemicolons(tokens ?? [])) {
+		if (t.type === T.LPAREN || t.type === T.LBRACKET || t.type === T.LBRACE)
+			depth++;
+		else if (
+			t.type === T.RPAREN ||
+			t.type === T.RBRACKET ||
+			t.type === T.RBRACE
+		)
+			depth--;
+		if (t.type === T.COMMA && depth === 0) parts.push([]);
+		else parts[parts.length - 1].push(t);
+	}
+	const exprs = [];
+	for (const part of parts) {
+		const parsed = parseExprTokens(part, false);
+		if (parsed.exprError) return { expr: null, exprError: parsed.exprError };
+		exprs.push(parsed.expr);
+	}
+	return { expr: exprs[0] ?? null, exprs };
+}
+
+// Parses an `if` condition; the lexer may leave the `if` keyword in front.
+function parseCondTokens(tokens) {
+	if (!tokens || tokens.length === 0) return { expr: null };
+	return parseExprTokens(
+		tokens[0]?.type === T.IF ? tokens.slice(1) : tokens,
+		false,
+	);
+}
+
+function isTemplRaw(toks) {
+	return (
+		toks.length >= 4 &&
+		toks[0]?.value === "templ" &&
+		toks[1]?.type === T.DOT &&
+		toks[2]?.value === "Raw" &&
+		toks[3]?.type === T.LPAREN
+	);
+}
+
+// Strips the trailing semicolons the Go lexer inserts at a newline.
+function trimSemicolons(tokens) {
+	let end = tokens.length;
+	while (end > 0 && tokens[end - 1].type === T.SEMICOLON) end--;
+	return tokens.slice(0, end);
+}
+
+// Parses a `for` header (the `for` keyword plus the clause, no body) as a
+// ForStmt, with a fake empty body `{ }` so the parser can complete it. A header
+// that is not a valid Go `for` clause gives `forStmt: null` plus its error.
+function parseForHeader(tokens) {
+	const eofTok = new Token(T.EOF, "", 1, 1);
+	const lbrace = new Token(T.LBRACE, "{", 1, 1);
+	const rbrace = new Token(T.RBRACE, "}", 1, 1);
+	const semi = new Token(T.SEMICOLON, ";", 1, 1);
+	const withFor =
+		tokens[0]?.type === T.FOR
+			? [...tokens, lbrace, rbrace, semi, eofTok]
+			: [
+					new Token(T.FOR, "for", 1, 1),
+					...tokens,
+					lbrace,
+					rbrace,
+					semi,
+					eofTok,
+				];
+	try {
+		return { forStmt: new Parser(withFor).parseFor() };
+	} catch (forError) {
+		return { forStmt: null, forError };
+	}
+}
+
+// Parses the `expr` and `cond-bool` attribute expressions of an element.
+function parseAttrExprs(attrs) {
+	for (const attr of attrs) {
+		if (attr.kind === "expr" || attr.kind === "cond-bool")
+			attach(attr, parseExprTokens(attr.tokens));
+	}
+	return attrs;
+}
+
 export class TemplParser extends Parser {
 	// ── Top-level declaration override ───────────────────────────
 
@@ -101,7 +236,7 @@ export class TemplParser extends Parser {
 				return {
 					kind: "TemplElement",
 					tag: t.value.tag,
-					attrs: t.value.attrs,
+					attrs: parseAttrExprs(t.value.attrs),
 					children: [],
 				};
 			}
@@ -110,13 +245,19 @@ export class TemplParser extends Parser {
 				return { kind: "TemplText", value: t.value };
 			case TT.TEMPL_EXPR:
 				this.advance();
-				return { kind: "TemplExpr", tokens: t.value };
+				return attach(
+					{ kind: "TemplExpr", tokens: t.value },
+					parseExprTokens(t.value),
+				);
 			case TT.TEMPL_COMP:
 				this.advance();
-				return { kind: "TemplComponent", tokens: t.value };
+				return this.templComponent(t.value);
 			case TT.TEMPL_CHILDREN:
 				this.advance();
-				return { kind: "TemplChildren" };
+				return attach(
+					{ kind: "TemplChildren", name: t.value },
+					parseExprTokens([new Token(T.IDENT, t.value, t.line, t.col)]),
+				);
 			case TT.TEMPL_IF: {
 				this.advance();
 				return this.parseTemplIf(t);
@@ -136,10 +277,20 @@ export class TemplParser extends Parser {
 		}
 	}
 
+	// `@templ.Raw(arg)` parses `arg`; any other component parses the whole call.
+	templComponent(tokens) {
+		const raw = isTemplRaw(tokens);
+		const parsed = parseExprTokens(
+			raw ? trimSemicolons(tokens).slice(4, -1) : tokens,
+		);
+		return attach({ kind: "TemplComponent", tokens }, { raw, ...parsed });
+	}
+
 	// Parse children of an element until the matching close tag.
 	parseHtmlElement() {
 		const openTok = this.advance(); // HTML_OPEN
-		const { tag, attrs } = openTok.value;
+		const { tag } = openTok.value;
+		const attrs = parseAttrExprs(openTok.value.attrs);
 
 		// Void elements have no children and no close tag even without />
 		if (VOID_ELEMENTS.has(tag)) {
@@ -186,14 +337,20 @@ export class TemplParser extends Parser {
 				else_ = this.parseHtmlChildren(); // else body until RBRACE
 			}
 		}
-		return { kind: "TemplIf", condTokens, then, else_ };
+		return attach(
+			{ kind: "TemplIf", condTokens, then, else_ },
+			parseCondTokens(condTokens),
+		);
 	}
 
 	// Parse a TemplFor node. `tok` is the TEMPL_FOR token (already advanced).
 	parseTemplFor(tok) {
 		const stmtTokens = tok.value;
 		const body = this.parseHtmlChildren();
-		return { kind: "TemplFor", stmtTokens, body };
+		return attach(
+			{ kind: "TemplFor", stmtTokens, body },
+			parseForHeader(trimSemicolons(stmtTokens)),
+		);
 	}
 
 	// Parse a TemplSwitch node. `tok` is the TEMPL_SWITCH token (already advanced).
@@ -209,17 +366,22 @@ export class TemplParser extends Parser {
 				const isDefault = this.check(TT.TEMPL_DEFAULT);
 				const caseTok = this.advance();
 				const body = this.parseTemplCaseBody();
-				cases.push({
-					kind: "TemplCase",
-					caseTokens: isDefault ? null : caseTok.value,
-					body,
-				});
+				const caseTokens = isDefault ? null : caseTok.value;
+				cases.push(
+					attach(
+						{ kind: "TemplCase", caseTokens, body },
+						isDefault ? { expr: null } : parseExprListTokens(caseTokens),
+					),
+				);
 			} else {
 				this.advance(); // skip unexpected
 			}
 		}
 		if (this.check(TT.TEMPL_END)) this.advance(); // consume closing }
-		return { kind: "TemplSwitch", exprTokens, cases };
+		return attach(
+			{ kind: "TemplSwitch", exprTokens, cases },
+			parseExprTokens(exprTokens),
+		);
 	}
 
 	// Parse HTML nodes for a switch case body — stops at CASE/DEFAULT/END/RBRACE.