@tsrx/core 0.1.62 → 0.1.63

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.63",
   "type": "module",
   "repository": {
     "type": "git",

package/src/plugin.js

@@ -108,6 +108,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 +358,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;
@@ -1514,6 +1598,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.
@@ -3236,6 +3339,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 +3434,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 +3444,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();

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;
 
 		/**