@tsrx/core 0.1.48 → 0.1.50

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "type": "module",
   "repository": {
     "type": "git",

package/src/index.js

@@ -204,7 +204,6 @@ export {
 	is_component_jsx_name,
 	is_jsx_child,
 	set_loc,
-	to_text_expression,
 } from './transform/jsx/ast-builders.js';
 export {
 	render_stylesheets as renderStylesheets,

package/src/plugin.js

@@ -273,6 +273,8 @@ export function TSRXPlugin(config) {
 			#controlFlowBlockAllowsNativeReturn = false;
 			#parsingJSXSwitchCaseScriptStatementDepth = 0;
 			#templateControlFlowBlockDepth = 0;
+			/** @type {AST.NodeWithLocation | null}	*/
+			#lastClauseKeywordSpan = null;
 			#templateControlFlowTryDepth = 0;
 			/** @type {Parse.Parser['context']} */
 			context = [b_stat];
@@ -1518,43 +1520,57 @@ export function TSRXPlugin(config) {
 					const previous_reading_header = this.#readingJSXControlFlowHeader;
 					this.#readingJSXControlFlowHeader = true;
 					try {
-						node = this.#finishJSXControlFlowExpression(
-							this.parseStatement(null),
-							'JSXForExpression',
-							start,
-							startLoc,
+						node = /** @type {AST.JSXForExpression} */ (
+							this.#finishJSXControlFlowExpression(
+								this.parseStatement(null),
+								'JSXForExpression',
+								start,
+								startLoc,
+							)
 						);
 					} finally {
 						this.#readingJSXControlFlowHeader = previous_reading_header;
 						this.#templateControlFlowBlockDepth--;
 					}
 					if (
-						/** @type {any} */ (node).statementType !== 'ForOfStatement' &&
-						/** @type {any} */ (node).statementType !== 'ForInStatement' &&
-						/** @type {any} */ (node).statementType !== 'ForStatement'
+						node.statementType !== 'ForOfStatement' &&
+						node.statementType !== 'ForInStatement' &&
+						node.statementType !== 'ForStatement'
 					) {
 						this.raise(start, 'Expected `for` after `@`.');
 					}
-					if (/** @type {any} */ (node).body?.type !== 'BlockStatement') {
-						this.raise(
-							/** @type {any} */ (node).body?.start ?? start,
-							'Expected `{` after JSX control-flow directive.',
-						);
+					if (node.body?.type !== 'BlockStatement') {
+						this.raise(node.body?.start ?? start, 'Expected `{` after JSX control-flow directive.');
 					}
 					if (this.#eatJSXForEmptyKeyword()) {
 						if (this.type !== tt.braceL) {
 							this.raise(this.start, 'Expected `{` after JSX control-flow directive.');
 						}
+						const emptyKeyword = this.#lastClauseKeywordSpan;
+						let empty;
 						this.#templateControlFlowBlockDepth++;
 						try {
-							/** @type {any} */ (node).empty = this.parseBlock();
+							empty = this.parseBlock();
 						} finally {
 							this.#templateControlFlowBlockDepth--;
 						}
+						node.empty = empty;
+						node.emptyKeyword = emptyKeyword;
+						// `@empty { … }` is part of the `@for` statement, but the node was
+						// already finished at the end of the for BODY (the clause is parsed
+						// after `#finishJSXControlFlowExpression`, unlike `@else`/`@catch`,
+						// which their own `parseStatement` consumes first). Extend it, or
+						// every consumer that slices by range — editor mappings, the
+						// playground's AST/position tracking, formatters, diagnostics —
+						// truncates the statement before its `@empty` clause.
+						node.end = empty.end;
+						/** @type {AST.NodeWithLocation} */ (node).loc.end =
+							/** @type {AST.NodeWithLocation} */ (empty).loc.end;
+						if (node.range) node.range[1] = /** @type {number} */ (empty.end);
 					} else if (this.#isUnprefixedDirectiveClauseContinuation('empty', ['{'])) {
 						this.raise(this.start, 'Expected `@empty` after `@for` block.');
 					} else {
-						/** @type {any} */ (node).empty = null;
+						node.empty = null;
 					}
 					return node;
 				}
@@ -1584,6 +1600,7 @@ export function TSRXPlugin(config) {
 			 * @param {string} keyword
 			 */
 			#eatJSXDirectiveClauseKeyword(keyword) {
+				this.#lastClauseKeywordSpan = null;
 				const keywordStart = skip_whitespace_from(this.input, this.start);
 				if (this.input.charCodeAt(keywordStart) !== CharCode.at) {
 					return false;
@@ -1596,6 +1613,19 @@ export function TSRXPlugin(config) {
 					return false;
 				}
 
+				// The clause keyword is the only authored spelling of `@empty`/`@else`/
+				// `@catch` and friends: the clause node itself starts at its `{`, so
+				// without this span nothing in the tree points at the keyword and
+				// tooling cannot resolve a cursor placed on it.
+				const keywordEnd = wordStart + keyword.length;
+				this.#lastClauseKeywordSpan = {
+					start: keywordStart,
+					end: keywordEnd,
+					loc: {
+						start: acorn.getLineInfo(this.input, keywordStart),
+						end: acorn.getLineInfo(this.input, keywordEnd),
+					},
+				};
 				this.pos = wordStart;
 				this.start = wordStart;
 				this.startLoc = acorn.getLineInfo(this.input, wordStart);
@@ -1714,6 +1744,7 @@ export function TSRXPlugin(config) {
 				node.alternate = null;
 
 				if (this.#eatJSXDirectiveClauseKeyword('else')) {
+					node.alternateKeyword = this.#lastClauseKeywordSpan;
 					node.alternate = this.#eatJSXDirectiveBareClauseKeyword('if')
 						? this.#parseTemplateIfStatement()
 						: /** @type {AST.Statement} */ (this.#parseTemplateControlFlowStatement());
@@ -1758,6 +1789,9 @@ export function TSRXPlugin(config) {
 							this.startNodeAt(clauseStart, clauseStartLoc)
 						);
 						current.consequent = [];
+						// `@case`/`@default` is the arm's only authored keyword; the node
+						// itself starts before the leading whitespace.
+						current.keyword = this.#lastClauseKeywordSpan;
 						const previous_reading_header = this.#readingJSXControlFlowHeader;
 						this.#readingJSXControlFlowHeader = true;
 						try {
@@ -3377,11 +3411,17 @@ export function TSRXPlugin(config) {
 				let node = /** @type {ESTreeJSX.JSXExpressionContainer} */ (this.startNode());
 				this.#jsxExpressionContainerDepth++;
 				let pushed_context_baseline = false;
+				// The stack depth with the container's `{` brace context on top, taken
+				// before `next()` so the first expression token's own context pushes
+				// (e.g. a fragment's `<` pushing its tag contexts) are not counted.
+				// This is the depth the stack must return to when the container's
+				// closing `}` is the current token.
+				const container_context_depth = this.context.length;
 				try {
 					this.next();
 
-					// Record the context-stack depth now that the container's `{` brace
-					// context is on the stack. A control-flow directive parsed inside this
+					// Record the context-stack depth now that the first expression token
+					// has been read. A control-flow directive parsed inside this
 					// container must not strip anything below this floor (see
 					// `#filterTemplateScriptContexts`).
 					this.#expressionContainerContextBaselines.push(this.context.length);
@@ -3401,6 +3441,19 @@ export function TSRXPlugin(config) {
 						this.next();
 					}
 					if (!consumeBraceAfterScope) {
+						// A control-flow directive expression restores the context stack from
+						// a snapshot taken inside this container
+						// (`#parseTemplateControlFlowBlock`), so the container's closing `}`
+						// — read while that stale snapshot was active — pops the wrong entry
+						// and leaves stale contexts above the enclosing tag's contexts (the
+						// directive's statement brace, or a wrapping fragment's child
+						// context). Once the `}` has been read the stack must be back at one
+						// below the container's depth (its own brace context popped); drop
+						// anything above that so the token after `}` (e.g. the `>` finishing
+						// the enclosing opening tag) tokenizes in the right context.
+						if (this.type === tt.braceR && this.context.length >= container_context_depth) {
+							this.context.length = container_context_depth - 1;
+						}
 						this.expect(tt.braceR);
 					}
 				} finally {
@@ -3719,6 +3772,7 @@ export function TSRXPlugin(config) {
 						node.handler = null;
 
 						if (this.#eatJSXDirectiveClauseKeyword('pending')) {
+							node.pendingKeyword = this.#lastClauseKeywordSpan;
 							node.pending = this.#parseTemplateControlFlowReturnBlock();
 						} else if (this.#isUnprefixedDirectiveClauseContinuation('pending', ['{'])) {
 							this.raise(this.start, 'Expected `@pending` after `@try` block.');
@@ -3729,6 +3783,7 @@ export function TSRXPlugin(config) {
 						const clauseStart = this.start;
 						const clauseStartLoc = this.startLoc;
 						if (this.#eatJSXDirectiveClauseKeyword('catch')) {
+							node.handlerKeyword = this.#lastClauseKeywordSpan;
 							if (this.type === tt._catch || this.value === 'catch') {
 								this.next();
 							}

package/src/transform/await.js

@@ -1,6 +1,10 @@
+/** @import * as AST from 'estree' */
+
+import { child_nodes, is_ast_node } from '../utils/ast.js';
+
 /**
- * @param {any[]} body_nodes
- * @returns {any | null}
+ * @param {AST.Node[]} body_nodes
+ * @returns {AST.TSRXAwaitNode | null}
  */
 export function find_first_top_level_await_in_tsrx_function_body(body_nodes) {
 	for (const node of body_nodes) {
@@ -12,12 +16,12 @@ export function find_first_top_level_await_in_tsrx_function_body(body_nodes) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | AST.Node[] | null | undefined} node
  * @param {boolean} inside_nested_function
- * @returns {any | null}
+ * @returns {AST.TSRXAwaitNode | null}
  */
 export function find_first_top_level_await(node, inside_nested_function) {
-	if (!node || typeof node !== 'object') {
+	if (!node) {
 		return null;
 	}
 
@@ -45,17 +49,15 @@ export function find_first_top_level_await(node, inside_nested_function) {
 	if (
 		node.type === 'AwaitExpression' ||
 		(node.type === 'ForOfStatement' && node.await === true) ||
-		(node.type === 'JSXForExpression' && node.await === true)
+		(node.type === 'JSXForExpression' &&
+			node.statementType === 'ForOfStatement' &&
+			node.await === true)
 	) {
 		return node;
 	}
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-
-		const found = find_first_top_level_await(node[key], false);
+	for (const child of child_nodes(node)) {
+		const found = find_first_top_level_await(child, false);
 		if (found) return found;
 	}
 

package/src/transform/jsx/ast-builders.js

@@ -2,7 +2,7 @@
 /** @import * as ESTreeJSX from 'estree-jsx' */
 
 import * as b from '../../utils/builders.js';
-import { has_location } from '../../utils/ast.js';
+import { has_location, is_ast_node } from '../../utils/ast.js';
 
 /**
  * AST-building utilities shared across every JSX target (React, Preact,
@@ -16,7 +16,7 @@ import { has_location } from '../../utils/ast.js';
  *
  * @template {AST.Node} T
  * @param {T} node
- * @param {AST.Node | AST.NodeWithLocation | undefined} source_node
+ * @param {AST.Node | AST.NodeWithLocation | null | undefined} source_node
  * @returns {T}
  */
 export function set_loc(node, source_node) {
@@ -127,14 +127,6 @@ export function add_extra_source_mappings_from_matching_expression(generated, so
 	}
 }
 
-/**
- * @param {unknown} value
- * @returns {value is AST.Node}
- */
-function is_ast_node(value) {
-	return !!value && typeof value === 'object' && 'type' in value;
-}
-
 /**
  * @returns {AST.Literal}
  */
@@ -385,77 +377,6 @@ export function flatten_switch_consequent(consequent) {
 	return result;
 }
 
-/**
- * @param {AST.Expression | null | undefined} expression
- * @returns {boolean}
- */
-function is_static_string_expression(expression) {
-	if (!expression) {
-		return false;
-	}
-	if (expression.type === 'Literal') {
-		return typeof expression.value === 'string';
-	}
-	if (expression.type === 'TemplateLiteral') {
-		return expression.expressions.length === 0;
-	}
-	return false;
-}
-
-/**
- * Build `expr == null ? '' : expr + ''` — the text-coerce form used when a
- * Ripple `{expr}` child must render as a string in JSX (React/Preact drop
- * booleans; Solid's default child semantics don't either). Solid uses this
- * via `to_jsx_child`; React/Preact wrap it in a JSXExpressionContainer.
- *
- * When the expression is statically a non-null string at the AST level —
- * a string `Literal` (`"hello"`, `'hello'`) or a `TemplateLiteral` with no
- * interpolations (`` `hello` ``) — the coercion is provably a no-op and
- * the literal is emitted as-is. Identifiers and any other expression type still
- * get the ternary because the AST alone can't prove they're non-null strings.
- *
- * @param {AST.Expression} expression
- * @param {AST.Node | AST.NodeWithLocation} [source_node]
- * @returns {AST.Expression}
- */
-export function to_text_expression(expression, source_node = expression) {
-	if (is_static_string_expression(expression)) {
-		return set_loc(clone_ast_node(expression), source_node);
-	}
-	return set_loc(
-		/** @type {AST.Expression} */ ({
-			type: 'ConditionalExpression',
-			test: {
-				type: 'BinaryExpression',
-				operator: '==',
-				left: clone_ast_node(expression),
-				right: create_null_literal(),
-				metadata: { path: [] },
-			},
-			consequent: {
-				type: 'Literal',
-				value: '',
-				raw: "''",
-				metadata: { path: [] },
-			},
-			alternate: {
-				type: 'BinaryExpression',
-				operator: '+',
-				left: clone_ast_node(expression),
-				right: {
-					type: 'Literal',
-					value: '',
-					raw: "''",
-					metadata: { path: [] },
-				},
-				metadata: { path: [] },
-			},
-			metadata: { path: [] },
-		}),
-		source_node,
-	);
-}
-
 /**
  * Deep-clone an AST subtree.
  *

package/src/transform/jsx/helpers.js

@@ -252,7 +252,7 @@ const LOCATION_WRAPPED_NODE_TYPES = new Set([
 
 /**
  * @param {AST.Node | null | undefined} node
- * @returns {boolean}
+ * @returns {node is AST.JSXIfExpression | (AST.IfStatement & { statementType: 'IfStatement' })}
  */
 export function is_template_if_node(node) {
 	return (
@@ -262,19 +262,24 @@ export function is_template_if_node(node) {
 }
 
 /**
+ * A `@for … of …` directive, in either the expression or the retyped statement
+ * form. `JSXForExpression` also covers `@for … in …` and plain `@for (;;)`, so
+ * both arms must check `statementType` — callers read for-of-only fields such
+ * as `await` off the result.
+ *
  * @param {AST.Node | null | undefined} node
- * @returns {boolean}
+ * @returns {node is AST.JSXForOfExpression | (AST.ForOfStatement & { statementType: 'ForOfStatement' })}
  */
 export function is_template_for_of_node(node) {
 	return (
-		node?.type === 'JSXForExpression' ||
-		(node?.type === 'ForOfStatement' && node?.statementType === 'ForOfStatement')
+		(node?.type === 'JSXForExpression' || node?.type === 'ForOfStatement') &&
+		node.statementType === 'ForOfStatement'
 	);
 }
 
 /**
  * @param {AST.Node | null | undefined} node
- * @returns {boolean}
+ * @returns {node is AST.JSXSwitchExpression | (AST.SwitchStatement & { statementType: 'SwitchStatement' })}
  */
 export function is_template_switch_node(node) {
 	return (
@@ -285,7 +290,7 @@ export function is_template_switch_node(node) {
 
 /**
  * @param {AST.Node | null | undefined} node
- * @returns {boolean}
+ * @returns {node is AST.JSXTryExpression | (AST.TryStatement & { statementType: 'TryStatement' })}
  */
 export function is_template_try_node(node) {
 	return (