@tsrx/core 0.1.62 → 0.1.64

package/src/transform/segments.js

@@ -1477,10 +1477,23 @@ export function convert_source_map_to_mappings(
 				if (node.type === 'AssignmentPattern') {
 					// We need a mapping for the whole AssignmentPattern for diagnostics
 					// Only enable diagnostic verification here to avoid duplicate mappings
-					// that can cause things like double definitions
-					mappings.push(
-						get_mapping_from_node(node, src_to_gen_map, gen_line_offsets, mapping_data_verify_only),
-					);
+					// that can cause things like double definitions. A type-only lazy
+					// pattern drops its leading `&`, so there is no generated source-map
+					// position for the AssignmentPattern's authored start; its child
+					// mappings still provide diagnostics for the emitted pattern/default.
+					if (
+						(node.left.type !== 'ObjectPattern' && node.left.type !== 'ArrayPattern') ||
+						!node.left.lazy
+					) {
+						mappings.push(
+							get_mapping_from_node(
+								node,
+								src_to_gen_map,
+								gen_line_offsets,
+								mapping_data_verify_only,
+							),
+						);
+					}
 				}
 
 				return;

package/src/utils/ast.js

@@ -167,14 +167,9 @@ export function is_code_block_function_body(node, parent) {
  * @returns {boolean}
  */
 export function is_statement_position(parent, child) {
+	if (is_statement_list_item(parent, child)) return true;
+
 	switch (parent.type) {
-		case 'Program':
-		case 'BlockStatement':
-			return parent.body.includes(/** @type {AST.Statement} */ (child));
-		case 'SwitchCase':
-			return parent.consequent.includes(/** @type {AST.Statement} */ (child));
-		case 'JSXCodeBlock':
-			return parent.body.includes(/** @type {AST.Statement} */ (child));
 		case 'IfStatement':
 			return parent.consequent === child || parent.alternate === child;
 		case 'ForStatement':
@@ -190,6 +185,94 @@ export function is_statement_position(parent, child) {
 	}
 }
 
+/**
+ * Returns whether `child` is a direct item in a statement list. Unlike
+ * {@link is_statement_position}, this deliberately excludes single-statement
+ * control-flow bodies: transforms may replace a list item with declarations,
+ * but a declaration is not valid in those braceless statement slots.
+ *
+ * @param {AST.Node} parent
+ * @param {AST.Node} child
+ * @returns {boolean}
+ */
+export function is_statement_list_item(parent, child) {
+	switch (parent.type) {
+		case 'Program':
+		case 'BlockStatement':
+		case 'JSXCodeBlock':
+			return parent.body.includes(/** @type {AST.Statement} */ (child));
+		case 'SwitchCase':
+			return parent.consequent.includes(/** @type {AST.Statement} */ (child));
+		default:
+			return false;
+	}
+}
+
+/**
+ * Whether `parent` preserves `child` as the same expression value. Looking
+ * through these wrappers keeps strict and editor-oriented ASTs on the same
+ * semantic path.
+ *
+ * @param {AST.Node} parent
+ * @param {AST.Node} child
+ * @returns {boolean}
+ */
+export 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
+	);
+}
+
+/**
+ * Whether a lazy destructuring assignment can be lowered from an expression
+ * statement into a declaration without changing the syntactic category of its
+ * parent slot. Transparent expression wrappers are allowed, but the assignment
+ * must otherwise be the whole statement and that statement must be a direct
+ * item in a statement list.
+ *
+ * This is the shared semantic boundary for both target-neutral diagnostics and
+ * lazy-ID allocation. Keeping those callers on one predicate ensures collect
+ * mode never allocates an ID for a shape that analysis has diagnosed.
+ *
+ * @param {AST.AssignmentExpression} node
+ * @param {AST.Node[]} path
+ * @returns {boolean}
+ */
+export function is_supported_lazy_assignment_position(node, path) {
+	if (
+		node.operator !== '=' ||
+		(node.left.type !== 'ObjectPattern' && node.left.type !== 'ArrayPattern') ||
+		!node.left.lazy
+	) {
+		return false;
+	}
+
+	/** @type {AST.Node} */
+	let child = node;
+
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const parent = path[i];
+		if (is_transparent_expression_wrapper(parent, child)) {
+			child = parent;
+			continue;
+		}
+
+		if (parent.type !== 'ExpressionStatement' || parent.expression !== child) return false;
+
+		const container = path[i - 1];
+		return !!container && is_statement_list_item(container, parent);
+	}
+
+	return false;
+}
+
 /**
  * Returns the closest native TSRX function in an ancestry path. By default,
  * function and class boundaries stop the search so callers only match direct

package/types/index.d.ts

@@ -170,6 +170,8 @@ export interface BaseNodeMetaData {
 	forceMapping?: boolean;
 	generated_loop_skip_if?: boolean;
 	lazy_id?: string;
+	/** The current var scope contains a lazy `var` binding in a JavaScript loop header. */
+	has_lazy_var_loop_descendants?: boolean;
 	disable_verification?: boolean;
 	/** Identifiers whose source ranges also map to this generated identifier. */
 	extra_source_mappings?: Array<(AST.Identifier | AST.PrivateIdentifier) & AST.NodeWithLocation>;

package/types/parse.d.ts

@@ -86,6 +86,11 @@ export namespace Parse {
 		parenthesizedAssign: number;
 		parenthesizedBind: number;
 		doubleProto: number;
+		/**
+		 * TSRX extension: position of a pending `&{…}`/`&[…]` lazy binding
+		 * pattern parsed in expression position, set only by TSRXPlugin.
+		 */
+		lazyBindingPos?: number;
 	}
 
 	/**
@@ -1605,11 +1610,13 @@ export namespace Parse {
 		 * @param node Expression to convert
 		 * @param isBinding Whether binding pattern
 		 * @param refDestructuringErrors Error collector
+		 * @param preserveTypeScriptWrapper Keep TS wrapper nodes (acorn-typescript extension)
 		 */
 		toAssignable(
 			node: AST.Node,
 			isBinding?: boolean,
 			refDestructuringErrors?: DestructuringErrors,
+			preserveTypeScriptWrapper?: boolean,
 		): AST.Pattern;
 
 		/**