@tsrx/core 0.1.62 → 0.1.64

package/src/plugin.js

@@ -49,6 +49,60 @@ const CharCode = Object.freeze({
 	closeBrace: 125,
 });
 
+/** @type {WeakMap<Parse.Parser, number[]>} */
+const parser_line_starts = new WeakMap();
+
+/**
+ * Resolve an offset without rescanning the source from the beginning on every
+ * TSRX tokenizer rewind. Acorn's `getLineInfo` is linear in the offset; the
+ * parser calls this path often enough that large modules otherwise pay a
+ * quadratic location-tracking cost.
+ *
+ * @param {Parse.Parser} parser
+ * @param {number} offset
+ * @returns {acorn.Position}
+ */
+function get_line_info(parser, offset) {
+	let starts = parser_line_starts.get(parser);
+	if (starts === undefined) {
+		starts = [0];
+		for (let i = 0; i < parser.input.length; i++) {
+			const ch = parser.input.charCodeAt(i);
+			if (ch === CharCode.carriageReturn && parser.input.charCodeAt(i + 1) === CharCode.lineFeed) {
+				i++;
+				starts.push(i + 1);
+			} else if (
+				ch === CharCode.lineFeed ||
+				ch === CharCode.carriageReturn ||
+				ch === 0x2028 ||
+				ch === 0x2029
+			) {
+				starts.push(i + 1);
+			}
+		}
+		parser_line_starts.set(parser, starts);
+	}
+
+	let low = 0;
+	let high = starts.length;
+	while (low + 1 < high) {
+		const middle = (low + high) >>> 1;
+		if (starts[middle] <= offset) low = middle;
+		else high = middle;
+	}
+	// `getLineInfo(input, offset)` treats a CR as a complete line break when
+	// `offset` points at the LF of a CRLF pair, even though later offsets treat
+	// the pair as one terminator. Preserve that boundary behavior exactly.
+	if (
+		offset > 0 &&
+		parser.input.charCodeAt(offset) === CharCode.lineFeed &&
+		parser.input.charCodeAt(offset - 1) === CharCode.carriageReturn
+	) {
+		return new acorn.Position(low + 2, 0);
+	}
+	return new acorn.Position(low + 1, offset - starts[low]);
+}
+
 // Transparent wrappers to look through when validating a dynamic tag
 // expression (`<{expr}>`), and syntax that disqualifies one outright.
 const DYNAMIC_TAG_WRAPPER_TYPES = new Set([
@@ -108,6 +162,88 @@ function get_argument_clash_reported_names(check_clashes) {
 	return reported_names;
 }
 
+/**
+ * The position of a pending `&{…}`/`&[…]` lazy binding pattern recorded on a
+ * DestructuringErrors context, or -1. Acorn's DestructuringErrors class knows
+ * nothing about the field, so absence means none was recorded.
+ *
+ * @param {Parse.DestructuringErrors | undefined | null} refDestructuringErrors
+ * @returns {number}
+ */
+function get_lazy_binding_pos(refDestructuringErrors) {
+	return refDestructuringErrors?.lazyBindingPos ?? -1;
+}
+
+/** @type {ReadonlySet<string>} */
+const lazy_target_wrapper_types = new Set([
+	'ParenthesizedExpression',
+	'TSAsExpression',
+	'TSSatisfiesExpression',
+	'TSNonNullExpression',
+	'TSTypeAssertion',
+	'TSTypeCastExpression',
+]);
+
+/**
+ * Whether the lazy binding pattern recorded at `pos` (the position of its `&`,
+ * one character before the pattern node) sits in a pattern-forming position of
+ * `node` — a slot that toAssignable converts into a binding or assignment
+ * target. A lazy pattern reached only through an expression position (for
+ * example as a member expression's object in `&{ a }.b = x`) is an expression
+ * use and must keep its pending error. `node` is the pre-conversion tree, so
+ * both the expression and pattern spellings of each slot appear here.
+ *
+ * @param {AST.Node | null | undefined} node
+ * @param {number} pos
+ * @returns {boolean}
+ */
+function pattern_position_contains_lazy(node, pos) {
+	if (!node || typeof node !== 'object') return false;
+	if (
+		/** @type {AST.ObjectPattern | AST.ArrayPattern} */ (node).lazy &&
+		/** @type {number} */ (node.start) === pos + 1
+	) {
+		return true;
+	}
+	// Parentheses and the TypeScript expression wrappers acorn-typescript's
+	// toAssignable unwraps when converting a target (`[&{ a }!] = arr`) — the
+	// wrapped node stays in a pattern-forming position. TSTypeCastExpression is
+	// internal to acorn-typescript, hence the string set rather than switch
+	// cases over the ESTree union.
+	if (lazy_target_wrapper_types.has(node.type)) {
+		return pattern_position_contains_lazy(
+			/** @type {{ expression: AST.Node }} */ (/** @type {unknown} */ (node)).expression,
+			pos,
+		);
+	}
+	switch (node.type) {
+		case 'ObjectExpression':
+		case 'ObjectPattern':
+			return node.properties.some((property) =>
+				pattern_position_contains_lazy(
+					property.type === 'Property'
+						? /** @type {AST.Node} */ (property.value)
+						: property.argument,
+					pos,
+				),
+			);
+		case 'ArrayExpression':
+		case 'ArrayPattern':
+			return node.elements.some(
+				(element) => element && pattern_position_contains_lazy(element, pos),
+			);
+		case 'AssignmentExpression':
+			return node.operator === '=' && pattern_position_contains_lazy(node.left, pos);
+		case 'AssignmentPattern':
+			return pattern_position_contains_lazy(node.left, pos);
+		case 'SpreadElement':
+		case 'RestElement':
+			return pattern_position_contains_lazy(node.argument, pos);
+		default:
+			return false;
+	}
+}
+
 /**
  * A `<` opens a tag only when the character after it can begin one: `/` for a
  * closing tag, `>` for a fragment, `{` for a dynamic tag, or an element or
@@ -276,6 +412,8 @@ export function TSRXPlugin(config) {
 			#errors = undefined;
 			/** @type {string | null} */
 			#filename = null;
+			/** @type {WeakMap<object, { names: Set<string>, lexicalLength: number, varLength: number }>} */
+			#localExportNamesByScope = new WeakMap();
 			#functionBodyDepth = 0;
 			#allowExpressionContainerTrailingSemicolon = false;
 			#jsxAttributeValueExpressionDepth = 0;
@@ -625,12 +763,12 @@ export function TSRXPlugin(config) {
 					}
 					if (this.#isTemplateBlockCommentStart(index)) {
 						const comment_start = index;
-						const comment_start_loc = acorn.getLineInfo(this.input, comment_start);
+						const comment_start_loc = get_line_info(this, comment_start);
 						const close = this.input.indexOf('*/', index + 2);
 						const value_end = close === -1 ? this.input.length : close;
 						index = close === -1 ? this.input.length : close + 2;
 						if (this.options.onComment && comment_start >= token_end) {
-							const comment_end_loc = acorn.getLineInfo(this.input, index);
+							const comment_end_loc = get_line_info(this, index);
 							this.options.onComment(
 								true,
 								this.input.slice(comment_start + 2, value_end),
@@ -657,7 +795,7 @@ export function TSRXPlugin(config) {
 					index++;
 				}
 
-				const endLoc = acorn.getLineInfo(this.input, index);
+				const endLoc = get_line_info(this, index);
 				const node = /** @type {ESTreeJSX.JSXText} */ (this.startNodeAt(start, this.startLoc));
 				node.value = value;
 				node.raw = this.input.slice(start, index);
@@ -709,7 +847,7 @@ export function TSRXPlugin(config) {
 					}
 				}
 				if (!has_newline) return;
-				const loc = acorn.getLineInfo(this.input, index);
+				const loc = get_line_info(this, index);
 				this.start = index;
 				this.startLoc = new acorn.Position(loc.line, loc.column);
 				if (this.pos <= index) {
@@ -738,8 +876,8 @@ export function TSRXPlugin(config) {
 					this.input.slice(start + 2, end),
 					start,
 					end,
-					acorn.getLineInfo(this.input, start),
-					acorn.getLineInfo(this.input, end),
+					get_line_info(this, start),
+					get_line_info(this, end),
 					metadata,
 				);
 			}
@@ -852,7 +990,7 @@ export function TSRXPlugin(config) {
 				}
 				this.pos = start;
 				this.start = start;
-				this.startLoc = acorn.getLineInfo(this.input, start);
+				this.startLoc = get_line_info(this, start);
 				this.exprAllowed = true;
 				this.#suppressTemplateRawTextToken = true;
 				this.next();
@@ -947,7 +1085,7 @@ export function TSRXPlugin(config) {
 					index++;
 				}
 
-				const endLoc = acorn.getLineInfo(this.input, index);
+				const endLoc = get_line_info(this, index);
 				const node = /** @type {ESTreeJSX.JSXText} */ (this.startNodeAt(start, this.startLoc));
 				node.value = this.input.slice(start, index);
 				node.raw = node.value;
@@ -1111,7 +1249,7 @@ export function TSRXPlugin(config) {
 				const start = this.pos;
 				const index = this.#templateRawTextEnd(start);
 
-				const endLoc = acorn.getLineInfo(this.input, index);
+				const endLoc = get_line_info(this, index);
 				const value = this.input.slice(start, index);
 				if (value.match(regex_newline_characters)) {
 					this.curLine = endLoc.line;
@@ -1310,7 +1448,7 @@ export function TSRXPlugin(config) {
 				let node;
 				try {
 					if (this.type === tstt.jsxText || this.type === tstt.jsxName) {
-						const loc = acorn.getLineInfo(this.input, this.start);
+						const loc = get_line_info(this, this.start);
 						this.pos = this.start;
 						this.curLine = loc.line;
 						this.lineStart = this.start - loc.column;
@@ -1345,7 +1483,7 @@ export function TSRXPlugin(config) {
 				// (a preceding setup statement's context restore can strip the JSX tag
 				// contexts the trailing `<`/`@` token first pushed).
 				if (this.start !== at_index) {
-					const loc = acorn.getLineInfo(this.input, at_index);
+					const loc = get_line_info(this, at_index);
 					this.pos = at_index;
 					this.start = at_index;
 					this.startLoc = new acorn.Position(loc.line, loc.column);
@@ -1457,7 +1595,7 @@ export function TSRXPlugin(config) {
 				if (this.curContext() !== b_stat) {
 					this.context.push(b_stat);
 				}
-				const braceLoc = acorn.getLineInfo(this.input, braceStart);
+				const braceLoc = get_line_info(this, braceStart);
 				this.pos = braceStart;
 				this.start = braceStart;
 				this.startLoc = new acorn.Position(braceLoc.line, braceLoc.column);
@@ -1514,6 +1652,25 @@ export function TSRXPlugin(config) {
 			 * @type {Parse.Parser['parseExprAtom']}
 			 */
 			parseExprAtom(refDestructuringErrors, forInit, forNew) {
+				// A `&{…}`/`&[…]` lazy binding pattern is only meaningful where the
+				// expression may still turn out to be a binding or assignment target —
+				// an arrow parameter list, a destructuring assignment target, or a
+				// for–of/for–in loop target. Those are exactly the positions Acorn
+				// parses with a DestructuringErrors context, so parse the pattern there
+				// and record it as a pending error the same way Acorn treats `{a = b}`
+				// shorthand: pattern conversion accepts the node as-is, while contexts
+				// that remain expressions raise in checkExpressionErrors.
+				if (
+					refDestructuringErrors &&
+					this.type === tt.bitwiseAND &&
+					(this.input.charCodeAt(this.end) === CharCode.openBrace ||
+						this.input.charCodeAt(this.end) === CharCode.openBracket)
+				) {
+					if (get_lazy_binding_pos(refDestructuringErrors) < 0) {
+						refDestructuringErrors.lazyBindingPos = this.start;
+					}
+					return /** @type {AST.Expression} */ (/** @type {unknown} */ (this.parseBindingAtom()));
+				}
 				// A token already consumed as JSX text (a script-mode element child) must
 				// stay text even when it happens to begin at an `@` — otherwise whether
 				// `@if` parses as a directive would depend on leading whitespace.
@@ -1578,7 +1735,7 @@ export function TSRXPlugin(config) {
 				const keywordStart = start + 1;
 				this.pos = keywordStart;
 				this.start = keywordStart;
-				this.startLoc = acorn.getLineInfo(this.input, keywordStart);
+				this.startLoc = get_line_info(this, keywordStart);
 				this.curLine = this.startLoc.line;
 				this.lineStart = keywordStart - this.startLoc.column;
 				this.#filterTemplateScriptContexts();
@@ -1711,13 +1868,13 @@ export function TSRXPlugin(config) {
 					start: keywordStart,
 					end: keywordEnd,
 					loc: {
-						start: acorn.getLineInfo(this.input, keywordStart),
-						end: acorn.getLineInfo(this.input, keywordEnd),
+						start: get_line_info(this, keywordStart),
+						end: get_line_info(this, keywordEnd),
 					},
 				};
 				this.pos = wordStart;
 				this.start = wordStart;
-				this.startLoc = acorn.getLineInfo(this.input, wordStart);
+				this.startLoc = get_line_info(this, wordStart);
 				this.curLine = this.startLoc.line;
 				this.lineStart = wordStart - this.startLoc.column;
 				this.#filterTemplateScriptContexts();
@@ -1753,7 +1910,7 @@ export function TSRXPlugin(config) {
 
 				this.pos = wordStart;
 				this.start = wordStart;
-				this.startLoc = acorn.getLineInfo(this.input, wordStart);
+				this.startLoc = get_line_info(this, wordStart);
 				this.curLine = this.startLoc.line;
 				this.lineStart = wordStart - this.startLoc.column;
 				this.#filterTemplateScriptContexts();
@@ -2108,12 +2265,12 @@ export function TSRXPlugin(config) {
 
 				if (relativeCloseStart !== -1) {
 					const closingStart = contentStart + content.length;
-					const closingLineInfo = acorn.getLineInfo(this.input, closingStart);
+					const closingLineInfo = get_line_info(this, closingStart);
 					const closingStartLoc = new acorn.Position(closingLineInfo.line, closingLineInfo.column);
 					const nameStart = closingStart + 2;
 					const nameEnd = nameStart + tagName.length;
-					const nameStartInfo = acorn.getLineInfo(this.input, nameStart);
-					const nameEndInfo = acorn.getLineInfo(this.input, nameEnd);
+					const nameStartInfo = get_line_info(this, nameStart);
+					const nameEndInfo = get_line_info(this, nameEnd);
 					const name = /** @type {ESTreeJSX.JSXIdentifier} */ (
 						this.startNodeAt(
 							nameStart,
@@ -2128,7 +2285,7 @@ export function TSRXPlugin(config) {
 						new acorn.Position(nameEndInfo.line, nameEndInfo.column),
 					);
 					const closingEnd = closingStart + closeTag.length;
-					const closingEndInfo = acorn.getLineInfo(this.input, closingEnd);
+					const closingEndInfo = get_line_info(this, closingEnd);
 					const closingElement =
 						/** @type {ESTreeJSX.TSRXJSXClosingElement & AST.NodeWithLocation} */ (
 							this.startNodeAt(closingStart, closingStartLoc)
@@ -2234,14 +2391,14 @@ export function TSRXPlugin(config) {
 				node.children = [];
 
 				if (content.length > 0) {
-					const bodyStartInfo = acorn.getLineInfo(this.input, open.end);
+					const bodyStartInfo = get_line_info(this, open.end);
 					const text = /** @type {ESTreeJSX.JSXText} */ (
 						this.startNodeAt(open.end, new acorn.Position(bodyStartInfo.line, bodyStartInfo.column))
 					);
 					text.value = content;
 					text.raw = content;
 					const bodyEnd = open.end + content.length;
-					const bodyEndInfo = acorn.getLineInfo(this.input, bodyEnd);
+					const bodyEndInfo = get_line_info(this, bodyEnd);
 					this.finishNodeAt(
 						text,
 						'JSXText',
@@ -2522,8 +2679,8 @@ export function TSRXPlugin(config) {
 			#report_recoverable_error_range(position, end, message, code) {
 				const start = Math.max(0, Math.min(position, this.input.length));
 				const range_end = Math.max(start, Math.min(end, this.input.length));
-				const start_loc = acorn.getLineInfo(this.input, start);
-				const end_loc = acorn.getLineInfo(this.input, range_end);
+				const start_loc = get_line_info(this, start);
+				const end_loc = get_line_info(this, range_end);
 
 				error(
 					message,
@@ -2923,7 +3080,7 @@ export function TSRXPlugin(config) {
 					this.input.charCodeAt(this.pos - 1) === CharCode.equals
 				) {
 					const start = this.pos - 1;
-					const loc = acorn.getLineInfo(this.input, start);
+					const loc = get_line_info(this, start);
 					this.start = start;
 					this.startLoc = loc;
 					this.pos++;
@@ -2975,7 +3132,7 @@ export function TSRXPlugin(config) {
 					this.input.charCodeAt(this.pos - 1) === CharCode.equals
 				) {
 					const start = this.pos - 1;
-					const loc = acorn.getLineInfo(this.input, start);
+					const loc = get_line_info(this, start);
 					this.start = start;
 					this.startLoc = loc;
 					this.pos++;
@@ -3236,6 +3393,89 @@ export function TSRXPlugin(config) {
 				return expr;
 			}
 
+			/**
+			 * A recorded lazy binding pattern that never became a binding or
+			 * assignment target is a pending error, exactly like `{a = b}` shorthand
+			 * outside a destructuring pattern. Acorn calls the throwing form at every
+			 * boundary where a context definitively stayed an expression
+			 * (parenthesized expressions, call arguments, plain assignments'
+			 * right-hand sides, …) — that is where the record is enforced.
+			 *
+			 * The non-throwing form is deliberately left untouched: Acorn uses it in
+			 * parseExprOps/parseMaybeConditional to stop parsing operators early, and
+			 * returning true there would cut the pattern off from the `as` /
+			 * `satisfies` operator lane before toAssignable can accept the wrapped
+			 * target (`[&{ a } as T] = arr`). Every path that keeps a stale record
+			 * still ends in a throwing check.
+			 *
+			 * @type {Parse.Parser['checkExpressionErrors']}
+			 */
+			checkExpressionErrors(refDestructuringErrors, andThrow) {
+				if (andThrow) {
+					const lazy_binding_pos = get_lazy_binding_pos(refDestructuringErrors);
+					if (lazy_binding_pos >= 0) {
+						this.raise(
+							lazy_binding_pos,
+							'Lazy binding patterns are only valid as binding or assignment targets',
+						);
+					}
+				}
+				return super.checkExpressionErrors(refDestructuringErrors, andThrow);
+			}
+
+			/**
+			 * acorn-typescript unwraps TS expression wrappers in checkLValSimple,
+			 * which is only right for simple targets (`[b as any] = arr`). A wrapped
+			 * destructuring pattern (`[&{ a } as T] = arr`) reaches checkLValPattern
+			 * still wrapped — toAssignableList ignores return values, so the wrapper
+			 * survives conversion — and would fall through to checkLValSimple's
+			 * "Assigning to rvalue". Unwrap here so wrapped patterns take the
+			 * pattern lane.
+			 *
+			 * @type {Parse.Parser['checkLValPattern']}
+			 */
+			checkLValPattern(expr, bindingType, checkClashes) {
+				let node = expr;
+				while (
+					node.type === 'TSNonNullExpression' ||
+					node.type === 'TSAsExpression' ||
+					node.type === 'TSSatisfiesExpression' ||
+					node.type === 'TSTypeAssertion'
+				) {
+					node = /** @type {AST.Node} */ (
+						/** @type {{ expression: AST.Node }} */ (/** @type {unknown} */ (node)).expression
+					);
+				}
+				return super.checkLValPattern(node, bindingType, checkClashes);
+			}
+
+			/**
+			 * Converting a node into an assignment target resolves any lazy binding
+			 * pattern recorded inside it — the pattern landed in a valid position,
+			 * so its pending error must not outlive the conversion (e.g.
+			 * `({ pair: &{ a } } = obj)` would otherwise still raise when the
+			 * enclosing parenthesized expression runs checkExpressionErrors). This
+			 * mirrors how Acorn resets `shorthandAssign` once the shorthand ends up
+			 * inside a converted left-hand side.
+			 *
+			 * @type {Parse.Parser['toAssignable']}
+			 */
+			toAssignable(node, isBinding, refDestructuringErrors, preserveTypeScriptWrapper) {
+				const lazy_binding_pos = get_lazy_binding_pos(refDestructuringErrors);
+				// Only a pattern-forming position resolves the record: a lazy pattern
+				// that is merely inside the target's span but reached through an
+				// expression position (`&{ a }.b = x`) is still an expression use.
+				if (lazy_binding_pos >= 0 && pattern_position_contains_lazy(node, lazy_binding_pos)) {
+					/** @type {Parse.DestructuringErrors} */ (refDestructuringErrors).lazyBindingPos = -1;
+				}
+				return super.toAssignable(
+					node,
+					isBinding,
+					refDestructuringErrors,
+					preserveTypeScriptWrapper,
+				);
+			}
+
 			/**
 			 * Override checkLocalExport to check all scopes in the scope stack.
 			 * This is needed because submodules create nested scopes, but exports
@@ -3248,8 +3488,7 @@ export function TSRXPlugin(config) {
 				if (this.hasImport(name)) return;
 				// Check all scopes in the scope stack, not just the top-level scope
 				for (let i = this.scopeStack.length - 1; i >= 0; i--) {
-					const scope = this.scopeStack[i];
-					if (scope.lexical.indexOf(name) !== -1 || scope.var.indexOf(name) !== -1) {
+					if (this.#scopeDeclaredNames(this.scopeStack[i]).has(name)) {
 						// Found in a scope, remove from undefinedExports if it was added
 						delete this.undefinedExports[name];
 						return;
@@ -3259,6 +3498,32 @@ export function TSRXPlugin(config) {
 				this.undefinedExports[name] = id;
 			}
 
+			/**
+			 * The names declared in `scope`, as a cached Set. Acorn only ever
+			 * appends to a scope's `lexical` and `var` arrays during the scope's
+			 * lifetime, so syncing from the last-seen lengths is enough to keep the
+			 * Set current.
+			 *
+			 * @param {{ lexical: string[], var: string[] }} scope
+			 * @returns {Set<string>}
+			 */
+			#scopeDeclaredNames(scope) {
+				let cached = this.#localExportNamesByScope.get(scope);
+				if (!cached) {
+					cached = { names: new Set(), lexicalLength: 0, varLength: 0 };
+					this.#localExportNamesByScope.set(scope, cached);
+				}
+				for (let i = cached.lexicalLength; i < scope.lexical.length; i++) {
+					cached.names.add(scope.lexical[i]);
+				}
+				for (let i = cached.varLength; i < scope.var.length; i++) {
+					cached.names.add(scope.var[i]);
+				}
+				cached.lexicalLength = scope.lexical.length;
+				cached.varLength = scope.var.length;
+				return cached.names;
+			}
+
 			/** @type {Parse.Parser['parseForStatement']} */
 			parseForStatement(node) {
 				this.next();
@@ -3612,8 +3877,8 @@ export function TSRXPlugin(config) {
 						}
 						const brace_start = skip_whitespace_from(this.input, name_end);
 						if (this.input.charCodeAt(brace_start) === CharCode.closeBrace) {
-							const name_start_loc = acorn.getLineInfo(this.input, name_start);
-							const name_end_loc = acorn.getLineInfo(this.input, name_end);
+							const name_start_loc = get_line_info(this, name_start);
+							const name_end_loc = get_line_info(this, name_end);
 							const name_value = this.input.slice(name_start, name_end);
 							const id = /** @type {ESTreeJSX.JSXIdentifier} */ (
 								this.startNodeAt(name_start, name_start_loc)
@@ -3633,14 +3898,14 @@ export function TSRXPlugin(config) {
 								expression,
 								'JSXExpressionContainer',
 								brace_start + 1,
-								acorn.getLineInfo(this.input, brace_start + 1),
+								get_line_info(this, brace_start + 1),
 							);
 							/** @type {ESTreeJSX.JSXAttribute} */ (node).name = id;
 							/** @type {ESTreeJSX.JSXAttribute} */ (node).value = expression;
 							/** @type {ESTreeJSX.JSXAttribute} */ (node).shorthand = true;
 
 							const end = brace_start + 1;
-							const endLoc = acorn.getLineInfo(this.input, end);
+							const endLoc = get_line_info(this, end);
 							this.pos = end;
 							this.curLine = endLoc.line;
 							this.lineStart = end - endLoc.column;
@@ -3893,7 +4158,7 @@ export function TSRXPlugin(config) {
 							if (this.input.charCodeAt(paramStart) === CharCode.openParen) {
 								this.pos = paramStart;
 								this.start = paramStart;
-								this.startLoc = acorn.getLineInfo(this.input, paramStart);
+								this.startLoc = get_line_info(this, paramStart);
 								this.curLine = this.startLoc.line;
 								this.lineStart = paramStart - this.startLoc.column;
 								this.#filterTemplateScriptContexts();
@@ -4063,7 +4328,7 @@ export function TSRXPlugin(config) {
 						this.input.charCodeAt(index + 1) === CharCode.greaterThan &&
 						this.context.includes(tstc.tc_expr)
 					) {
-						const loc = acorn.getLineInfo(this.input, index);
+						const loc = get_line_info(this, index);
 						this.pos = index;
 						this.start = index;
 						this.startLoc = loc;
@@ -4256,7 +4521,7 @@ export function TSRXPlugin(config) {
 								!this.#shouldReadTemplateRawTextToken()
 							) {
 								const start = this.pos - 1;
-								const loc = acorn.getLineInfo(this.input, start);
+								const loc = get_line_info(this, start);
 								this.start = start;
 								this.startLoc = loc;
 								this.pos++;
@@ -4607,7 +4872,7 @@ export function TSRXPlugin(config) {
 						);
 						text_node.value = ws_value;
 						text_node.raw = ws_value;
-						const loc = acorn.getLineInfo(this.input, at_index);
+						const loc = get_line_info(this, at_index);
 						const at_position = new acorn.Position(loc.line, loc.column);
 						this.finishNodeAt(text_node, 'JSXText', at_index, at_position);
 						if (this.#shouldKeepTemplateTextNode(text_node)) {
@@ -4717,7 +4982,7 @@ export function TSRXPlugin(config) {
 						this.start > blockEnd &&
 						/^\s*$/.test(this.input.slice(blockEnd, this.start))
 					) {
-						const loc = acorn.getLineInfo(this.input, blockEnd);
+						const loc = get_line_info(this, blockEnd);
 						this.pos = blockEnd;
 						this.start = blockEnd;
 						this.startLoc = new acorn.Position(loc.line, loc.column);
@@ -5162,7 +5427,16 @@ export function TSRXPlugin(config) {
 			parseBlock(createNewLexicalScope, node, exitStrict) {
 				const parent = this.#path.at(-1);
 
-				if (this.#isNativeTemplateNode(parent) && this.#templateControlFlowBlockDepth > 0) {
+				// `#templateControlFlowBlockDepth` alone decides here — don't also
+				// require `#isNativeTemplateNode(parent)`: a directive body's own
+				// parsing (`#parseTemplateControlFlowBlock`) empties `#path`, so for
+				// a `@for` nested inside another directive's branch, `parent` is
+				// `undefined` and that check would skip this redirect, dropping the
+				// `@for`'s body into plain statement parsing (nested directives then
+				// land in expression position instead of template position). The
+				// depth counter is set only around a `@for`'s own header+body and
+				// `@empty` clause, so plain JS `for` loops can't false-positive.
+				if (this.#templateControlFlowBlockDepth > 0) {
 					this.#templateControlFlowBlockDepth--;
 					try {
 						return this.#parseTemplateControlFlowBlock(createNewLexicalScope, node, exitStrict);