@tsrx/core 0.1.62 → 0.1.64

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "type": "module",
   "repository": {
     "type": "git",
@@ -79,7 +79,7 @@
     "is-reference": "^3.0.3",
     "magic-string": "^0.30.18",
     "zimmerframe": "^1.1.2",
-    "@tsrx/runtime": "0.1.2"
+    "@tsrx/runtime": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/src/analyze/index.js

@@ -7,30 +7,75 @@ import { walk } from 'zimmerframe';
 import {
 	is_code_block_function_body,
 	is_statement_position,
+	is_supported_lazy_assignment_position,
+	is_transparent_expression_wrapper,
 	is_tsrx_render_output_node,
 } from '../utils/ast.js';
-import { validate_forgotten_statement_container } from './validation.js';
+import {
+	validate_forgotten_statement_container,
+	validate_unsupported_lazy_assignment_position,
+} from './validation.js';
 
 /**
- * Wrappers that preserve an expression's value and therefore do not turn a
- * template into a used value on their own. Looking through them keeps strict
- * builds and `preserveParens` type-only builds on the same diagnostic path.
+ * Find the first authored lazy pattern along an assignment target's binding
+ * edges. Default-value expressions and computed keys are evaluated
+ * expressions, so nested assignments there own their own diagnostics.
  *
- * @param {AST.Node} parent
- * @param {AST.Node} child
- * @returns {boolean}
+ * @param {AST.Node} node
+ * @returns {import('../../types/index').LazyPattern | null}
  */
-function is_transparent_expression_wrapper(parent, child) {
-	return (
-		(parent.type === 'ParenthesizedExpression' ||
-			parent.type === 'TSAsExpression' ||
-			parent.type === 'TSSatisfiesExpression' ||
-			parent.type === 'TSNonNullExpression' ||
-			parent.type === 'TSInstantiationExpression' ||
-			parent.type === 'TSTypeAssertion' ||
-			parent.type === 'ChainExpression') &&
-		/** @type {{ expression?: AST.Node }} */ (parent).expression === child
-	);
+function find_first_lazy_pattern(node) {
+	if ((node.type === 'ObjectPattern' || node.type === 'ArrayPattern') && node.lazy) {
+		return node;
+	}
+
+	switch (node.type) {
+		case 'AssignmentPattern':
+			return find_first_lazy_pattern(node.left);
+		case 'RestElement':
+			return find_first_lazy_pattern(node.argument);
+		case 'ObjectPattern':
+			for (const property of node.properties) {
+				const lazy =
+					property.type === 'Property'
+						? find_first_lazy_pattern(property.value)
+						: find_first_lazy_pattern(property.argument);
+				if (lazy) return lazy;
+			}
+			return null;
+		case 'ArrayPattern':
+			for (const element of node.elements) {
+				if (!element) continue;
+				const lazy = find_first_lazy_pattern(element);
+				if (lazy) return lazy;
+			}
+			return null;
+		default: {
+			const expression = /** @type {{ expression?: AST.Node }} */ (node).expression;
+			return expression && is_transparent_expression_wrapper(node, expression)
+				? find_first_lazy_pattern(expression)
+				: null;
+		}
+	}
+}
+
+/**
+ * @param {AST.AssignmentExpression} node
+ * @param {{ next: () => unknown, path: AST.Node[], state: TSRXAnalysisState }} context
+ */
+function visit_assignment_expression(node, { next, path, state }) {
+	const lazy = find_first_lazy_pattern(node.left);
+
+	if (lazy && !is_supported_lazy_assignment_position(node, path)) {
+		validate_unsupported_lazy_assignment_position(
+			lazy,
+			state.filename,
+			state.collect ? state.errors : undefined,
+			state.comments,
+		);
+	}
+
+	next();
 }
 
 /**
@@ -126,6 +171,8 @@ function visit_class(_node, { next, state }) {
 }
 
 const visitors = {
+	AssignmentExpression: visit_assignment_expression,
+
 	FunctionDeclaration: visit_function,
 	FunctionExpression: visit_function,
 	ArrowFunctionExpression: visit_function,

package/src/analyze/validation.js

@@ -30,6 +30,8 @@ export const TSRX_DO_WHILE_STATEMENT_ERROR =
 	'Do...while loops are not supported in TSRX templates. Move the do...while loop into a function.';
 export const TSRX_FORGOTTEN_STATEMENT_CONTAINER_ERROR =
 	"This TSRX template output is unused. Return it, assign it to a value that is rendered, or make it part of the rendered output of a function '@{...}' body.";
+export const TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR =
+	'Lazy destructuring assignments require a directly lazy target as a standalone statement inside a program, block, TSRX code block, or switch case.';
 
 const invalid_nestings = {
 	// <p> cannot contain block-level elements
@@ -220,6 +222,23 @@ export function validate_forgotten_statement_container(node, filename, errors, c
 	);
 }
 
+/**
+ * @param {import('../../types/index').LazyPattern} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_unsupported_lazy_assignment_position(node, filename, errors, comments) {
+	error(
+		TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR,
+		filename ?? null,
+		node,
+		errors,
+		comments,
+		DIAGNOSTIC_CODES.UNSUPPORTED_LAZY_ASSIGNMENT_POSITION,
+	);
+}
+
 /**
  * @param {AST.ReturnStatement} node
  * @param {string | null | undefined} filename

package/src/diagnostics.js

@@ -5,4 +5,5 @@ export const DIAGNOSTIC_CODES = {
 	TEMPLATE_EXPRESSION_TRAILING_SEMICOLON: 'tsrx-template-expression-trailing-semicolon',
 	TEMPLATE_RETURN_STATEMENT: 'tsrx-template-return-statement',
 	FORGOTTEN_STATEMENT_CONTAINER: 'tsrx-forgotten-statement-container',
+	UNSUPPORTED_LAZY_ASSIGNMENT_POSITION: 'tsrx-unsupported-lazy-assignment-position',
 };

package/src/index.js

@@ -94,6 +94,7 @@ export {
 	is_template_directive as isTemplateDirective,
 	is_tsrx_render_output_node as isTsrxRenderOutputNode,
 	is_code_block_function_body as isCodeBlockFunctionBody,
+	is_statement_list_item as isStatementListItem,
 	is_statement_position as isStatementPosition,
 } from './utils/ast.js';
 
@@ -262,6 +263,7 @@ export {
 	TSRX_LOOP_CONTINUE_ERROR,
 	TSRX_LOOP_RETURN_ERROR,
 	TSRX_RETURN_STATEMENT_ERROR,
+	TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR,
 	TSRX_WHILE_STATEMENT_ERROR,
 	get_return_keyword_node as getReturnKeywordNode,
 	get_statement_keyword_node as getStatementKeywordNode,
@@ -272,6 +274,7 @@ export {
 	validate_tsrx_loop_continue_statement as validateTsrxLoopContinueStatement,
 	validate_tsrx_loop_return_statement as validateTsrxLoopReturnStatement,
 	validate_tsrx_return_statement as validateTsrxReturnStatement,
+	validate_unsupported_lazy_assignment_position as validateUnsupportedLazyAssignmentPosition,
 	validate_tsrx_unsupported_loop_statement as validateTsrxUnsupportedLoopStatement,
 	validate_forgotten_statement_container as validateForgottenStatementContainer,
 	validate_nesting as validateNesting,