esrap 2.2.11 → 2.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esrap",
-  "version": "2.2.11",
+  "version": "2.2.13",
   "description": "Parse in reverse",
   "repository": {
     "type": "git",

package/src/languages/ts/index.js

@@ -511,23 +511,11 @@ export default (options = {}) => {
 			// 	// Avoids confusion in `for` loops initializers
 			// 	chunks.write('(');
 			// }
-			if (needs_parens(node.left, node, false)) {
-				context.write('(');
-				context.visit(node.left);
-				context.write(')');
-			} else {
-				context.visit(node.left);
-			}
+			maybe_wrap(context, node.left, operand_needs_wrap(node.left, node, false));
 
 			context.write(` ${node.operator} `);
 
-			if (needs_parens(node.right, node, true)) {
-				context.write('(');
-				context.visit(node.right);
-				context.write(')');
-			} else {
-				context.visit(node.right);
-			}
+			maybe_wrap(context, node.right, operand_needs_wrap(node.right, node, true));
 		},
 
 		/**
@@ -575,17 +563,11 @@ export default (options = {}) => {
 				write_keyword(context, node, 'new', ' ');
 			}
 
-			const needs_parens =
+			const wrap =
+				node.callee.type === 'ChainExpression' ||
 				EXPRESSIONS_PRECEDENCE[node.callee.type] < EXPRESSIONS_PRECEDENCE.CallExpression ||
 				(node.type === 'NewExpression' && has_call_expression(node.callee));
-
-			if (needs_parens) {
-				context.write('(');
-				context.visit(node.callee);
-				context.write(')');
-			} else {
-				context.visit(node.callee);
-			}
+			maybe_wrap(context, node.callee, wrap);
 
 			if (/** @type {TSESTree.CallExpression} */ (node).optional) {
 				context.write('?.');
@@ -671,12 +653,25 @@ export default (options = {}) => {
 
 			if (node.id) {
 				context.visit(node.id);
+			}
+
+			if (node.typeParameters) {
+				context.visit(node.typeParameters);
+			}
+
+			if (node.id || node.typeParameters) {
 				context.write(' ');
 			}
 
 			if (node.superClass) {
 				context.write('extends ');
+				// the `extends` clause is a LeftHandSideExpression; anything lower (a
+				// logical/binary/conditional/etc.) must be parenthesized
+				const wrap_super =
+					EXPRESSIONS_PRECEDENCE[node.superClass.type] < EXPRESSIONS_PRECEDENCE.NewExpression;
+				if (wrap_super) context.write('(');
 				context.visit(node.superClass);
+				if (wrap_super) context.write(')');
 
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
 				var type_arguments = node.superTypeParameters ?? node.superTypeArguments;
@@ -813,6 +808,12 @@ export default (options = {}) => {
 			context.visit(node.key);
 			if (node.computed) context.write(']');
 
+			// optional method (`m?()`)
+			if (node.optional) context.write('?');
+
+			// @ts-expect-error `typeParameters` lives on the method node, not its value
+			if (node.typeParameters) context.visit(node.typeParameters);
+
 			context.write('(');
 			sequence(
 				context,
@@ -845,6 +846,8 @@ export default (options = {}) => {
 
 			const kw = create_keyword_write(context, node, field_modifiers_keywords_map_ok);
 
+			if (node.declare) kw('declare ');
+
 			if (node.accessibility) {
 				kw(node.accessibility + ' ');
 			}
@@ -862,6 +865,10 @@ export default (options = {}) => {
 				kw('static ');
 			}
 
+			if (node.override) kw('override ');
+
+			if (node.readonly) kw('readonly ');
+
 			if (
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
 				node.accessor ||
@@ -879,6 +886,10 @@ export default (options = {}) => {
 				context.visit(node.key);
 			}
 
+			// `x?: T` (optional) / `x!: T` (definite assignment)
+			if (node.optional) context.write('?');
+			else if (node.definite) context.write('!');
+
 			if (node.typeAnnotation) {
 				if (node.type === 'AccessorProperty' || node.type === 'TSAbstractAccessorProperty') {
 					context.visit(node.typeAnnotation);
@@ -926,7 +937,6 @@ export default (options = {}) => {
 			}
 
 			context.write('(');
-
 			sequence(
 				context,
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
@@ -953,7 +963,6 @@ export default (options = {}) => {
 			if (node.typeParameters) context.visit(node.typeParameters);
 
 			context.write('(');
-
 			sequence(
 				context,
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
@@ -964,8 +973,9 @@ export default (options = {}) => {
 					null,
 				false
 			);
+			context.write(')');
 
-			context.write(') => ');
+			context.write(' => ');
 
 			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
 			context.visit(node.typeAnnotation?.typeAnnotation ?? node.returnType?.typeAnnotation);
@@ -1011,13 +1021,7 @@ export default (options = {}) => {
 
 			context.write(' => ');
 
-			if (arrow_concise_body_needs_wrap(node.body)) {
-				context.write('(');
-				context.visit(node.body);
-				context.write(')');
-			} else {
-				context.visit(node.body);
-			}
+			maybe_wrap(context, node.body, arrow_concise_body_needs_wrap(node.body));
 		},
 
 		AssignmentExpression(node, context) {
@@ -1076,13 +1080,9 @@ export default (options = {}) => {
 		ClassExpression: shared['ClassDeclaration|ClassExpression'],
 
 		ConditionalExpression(node, context) {
-			if (EXPRESSIONS_PRECEDENCE[node.test.type] > EXPRESSIONS_PRECEDENCE.ConditionalExpression) {
-				context.visit(node.test);
-			} else {
-				context.write('(');
-				context.visit(node.test);
-				context.write(')');
-			}
+			const wrap =
+				EXPRESSIONS_PRECEDENCE[node.test.type] <= EXPRESSIONS_PRECEDENCE.ConditionalExpression;
+			maybe_wrap(context, node.test, wrap);
 
 			const consequent = context.new();
 			const alternate = context.new();
@@ -1130,7 +1130,14 @@ export default (options = {}) => {
 
 		Decorator(node, context) {
 			context.write('@');
+			// a decorator must be an identifier/member/call (or parenthesized); anything
+			// else (ternary, logical, assignment, unary, `as`, optional chain…) needs wrapping
+			const wrap =
+				/** @type {string} */ (node.expression.type) === 'ChainExpression' ||
+				EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.CallExpression;
+			if (wrap) context.write('(');
 			context.visit(node.expression);
+			if (wrap) context.write(')');
 			context.newline();
 		},
 
@@ -1240,20 +1247,9 @@ export default (options = {}) => {
 		},
 
 		ExpressionStatement(node, context) {
-			if (
-				node.expression.type === 'ObjectExpression' ||
-				(node.expression.type === 'AssignmentExpression' &&
-					node.expression.left.type === 'ObjectPattern') ||
-				node.expression.type === 'FunctionExpression'
-			) {
-				// is an AssignmentExpression to an ObjectPattern
-				context.write('(');
-				context.visit(node.expression);
-				context.write(');');
-				return;
-			}
-
-			context.visit(node.expression);
+			// would otherwise be parsed as a block / function / class declaration
+			const wrap = leads_with_curly_or_keyword(node.expression);
+			maybe_wrap(context, node.expression, wrap);
 			context.write(';');
 		},
 
@@ -1289,6 +1285,9 @@ export default (options = {}) => {
 			let name = node.name;
 			context.write(name, node);
 
+			// optional parameters (`a?: T`) carry `optional` on the identifier
+			if (node.optional) context.write('?');
+
 			if (node.typeAnnotation) context.visit(node.typeAnnotation);
 		},
 
@@ -1436,13 +1435,10 @@ export default (options = {}) => {
 		LogicalExpression: shared['BinaryExpression|LogicalExpression'],
 
 		MemberExpression(node, context) {
-			if (EXPRESSIONS_PRECEDENCE[node.object.type] < EXPRESSIONS_PRECEDENCE.MemberExpression) {
-				context.write('(');
-				context.visit(node.object);
-				context.write(')');
-			} else {
-				context.visit(node.object);
-			}
+			const wrap =
+				node.object.type === 'ChainExpression' ||
+				EXPRESSIONS_PRECEDENCE[node.object.type] < EXPRESSIONS_PRECEDENCE.MemberExpression;
+			maybe_wrap(context, node.object, wrap);
 
 			if (node.computed) {
 				if (node.optional) {
@@ -1483,9 +1479,7 @@ export default (options = {}) => {
 
 		// @ts-expect-error this isn't a real node type, but Acorn produces it
 		ParenthesizedExpression(node, context) {
-			context.write('(');
-			context.visit(node.expression);
-			context.write(')');
+			maybe_wrap(context, node.expression, true);
 		},
 
 		PrivateIdentifier(node, context) {
@@ -1634,7 +1628,12 @@ export default (options = {}) => {
 		},
 
 		TaggedTemplateExpression(node, context) {
-			context.visit(node.tag);
+			// the tag is a LeftHandSideExpression; a lower-precedence tag (logical,
+			// conditional, arrow, `as`, unary…) or an optional chain must be wrapped
+			const wrap =
+				/** @type {string} */ (node.tag.type) === 'ChainExpression' ||
+				EXPRESSIONS_PRECEDENCE[node.tag.type] < EXPRESSIONS_PRECEDENCE.CallExpression;
+			maybe_wrap(context, node.tag, wrap);
 			context.visit(node.quasi);
 		},
 
@@ -1707,15 +1706,19 @@ export default (options = {}) => {
 
 			if (node.operator.length > 1) {
 				context.write(' ');
+			} else if (
+				(node.operator === '+' || node.operator === '-') &&
+				((node.argument.type === 'UnaryExpression' && node.argument.operator === node.operator) ||
+					(node.argument.type === 'UpdateExpression' &&
+						node.argument.prefix &&
+						node.argument.operator[0] === node.operator))
+			) {
+				context.write(' ');
 			}
 
-			if (EXPRESSIONS_PRECEDENCE[node.argument.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression) {
-				context.write('(');
-				context.visit(node.argument);
-				context.write(')');
-			} else {
-				context.visit(node.argument);
-			}
+			const wrap =
+				EXPRESSIONS_PRECEDENCE[node.argument.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression;
+			maybe_wrap(context, node.argument, wrap);
 		},
 
 		UpdateExpression(node, context) {
@@ -1883,7 +1886,9 @@ export default (options = {}) => {
 		},
 
 		TSPropertySignature(node, context) {
+			if (node.computed) context.write('[');
 			context.visit(node.key);
+			if (node.computed) context.write(']');
 			if (node.optional) context.write('?');
 			if (node.typeAnnotation) context.visit(node.typeAnnotation);
 		},
@@ -1951,13 +1956,9 @@ export default (options = {}) => {
 			context.write('<');
 			context.visit(node.typeAnnotation);
 			context.write('>');
-			if (EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSTypeAssertion) {
-				context.write('(');
-				context.visit(node.expression);
-				context.write(')');
-			} else {
-				context.visit(node.expression);
-			}
+			const wrap =
+				EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSTypeAssertion;
+			maybe_wrap(context, node.expression, wrap);
 		},
 
 		TSTypeParameterInstantiation(node, context) {
@@ -1979,6 +1980,11 @@ export default (options = {}) => {
 		},
 
 		TSTypeParameter(node, context) {
+			// modifiers: `const T`, `in T` / `out T` (variance)
+			if (node.const) context.write('const ');
+			if (node.in) context.write('in ');
+			if (node.out) context.write('out ');
+
 			if (node.name && node.name.type) context.visit(node.name);
 			// @ts-expect-error type mismatch TSESTree and acorn-typescript?
 			else context.write(node.name, node);
@@ -1995,19 +2001,14 @@ export default (options = {}) => {
 		},
 
 		TSTypePredicate(node, context) {
-			if (node.parameterName) {
-				context.visit(node.parameterName);
-			} else if (node.typeAnnotation) {
-				context.visit(node.typeAnnotation);
-			}
+			// `asserts` precedes the parameter name; `is <type>` follows it. Forms:
+			// `x is T`, `asserts x is T`, `asserts x`
+			if (node.asserts) context.write('asserts ');
 
-			if (node.asserts) {
-				context.write(' asserts ');
-			} else {
-				context.write(' is ');
-			}
+			if (node.parameterName) context.visit(node.parameterName);
 
 			if (node.typeAnnotation) {
+				context.write(' is ');
 				context.visit(node.typeAnnotation.typeAnnotation);
 			}
 		},
@@ -2045,7 +2046,16 @@ export default (options = {}) => {
 		},
 
 		TSMappedType(node, context) {
-			context.write('{[');
+			context.write('{');
+
+			// `readonly` / `+readonly` / `-readonly` modifier
+			if (node.readonly) {
+				context.write(
+					node.readonly === '-' ? '-readonly ' : node.readonly === '+' ? '+readonly ' : 'readonly '
+				);
+			}
+
+			context.write('[');
 
 			const legacy_type_parameter = node.typeParameter;
 			const key = node.key ?? legacy_type_parameter?.name;
@@ -2062,8 +2072,19 @@ export default (options = {}) => {
 				context.visit(constraint);
 			}
 
+			// `as` key remapping
+			if (node.nameType) {
+				context.write(' as ');
+				context.visit(node.nameType);
+			}
+
 			context.write(']');
 
+			// `?` / `+?` / `-?` optionality modifier
+			if (node.optional) {
+				context.write(node.optional === '-' ? '-?' : node.optional === '+' ? '+?' : '?');
+			}
+
 			if (node.typeAnnotation) {
 				context.write(': ');
 				context.visit(node.typeAnnotation);
@@ -2073,10 +2094,11 @@ export default (options = {}) => {
 		},
 
 		TSMethodSignature(node, context) {
+			if (node.computed) context.write('[');
 			context.visit(node.key);
+			if (node.computed) context.write(']');
 
 			context.write('(');
-
 			sequence(
 				context,
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
@@ -2190,16 +2212,9 @@ export default (options = {}) => {
 
 		TSAsExpression(node, context) {
 			if (node.expression) {
-				const needs_parens =
+				const wrap =
 					EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSAsExpression;
-
-				if (needs_parens) {
-					context.write('(');
-					context.visit(node.expression);
-					context.write(')');
-				} else {
-					context.visit(node.expression);
-				}
+				maybe_wrap(context, node.expression, wrap);
 			}
 			context.write(' as ');
 			context.visit(node.typeAnnotation);
@@ -2239,21 +2254,24 @@ export default (options = {}) => {
 				context.visit(node.id);
 			}
 
-			if (!node.body) return;
-			context.visit(node.body);
+			// a qualified name (`namespace A.B.C`) is represented as nested
+			// `TSModuleDeclaration`s whose body is the next name part, not a block
+			let body = /** @type {any} */ (node.body);
+			while (body && body.type === 'TSModuleDeclaration') {
+				context.write('.');
+				context.visit(body.id);
+				body = body.body;
+			}
+
+			if (!body) return;
+			context.visit(body);
 		},
 
 		TSNonNullExpression(node, context) {
 			// operator expressions can't take a postfix `!` directly: `(0 as number)!`, `(await x)!`
-			if (
-				EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSNonNullExpression
-			) {
-				context.write('(');
-				context.visit(node.expression);
-				context.write(')');
-			} else {
-				context.visit(node.expression);
-			}
+			const wrap =
+				EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSNonNullExpression;
+			maybe_wrap(context, node.expression, wrap);
 			context.write('!');
 		},
 
@@ -2287,24 +2305,15 @@ export default (options = {}) => {
 
 		//@ts-expect-error I don't know why, but this is relied upon in the tests, but doesn't exist in the TSESTree types
 		TSParenthesizedType(node, context) {
-			context.write('(');
-			context.visit(node.typeAnnotation);
-			context.write(')');
+			maybe_wrap(context, node.typeAnnotation, true);
 		},
 
 		TSSatisfiesExpression(node, context) {
 			if (node.expression) {
-				const needs_parens =
+				const wrap =
 					EXPRESSIONS_PRECEDENCE[node.expression.type] <
 					EXPRESSIONS_PRECEDENCE.TSSatisfiesExpression;
-
-				if (needs_parens) {
-					context.write('(');
-					context.visit(node.expression);
-					context.write(')');
-				} else {
-					context.visit(node.expression);
-				}
+				maybe_wrap(context, node.expression, wrap);
 			}
 			context.write(' satisfies ');
 			context.visit(node.typeAnnotation);
@@ -2364,7 +2373,7 @@ function arrow_concise_body_needs_wrap(body) {
  * @param {boolean} is_right
  * @returns
  */
-function needs_parens(node, parent, is_right) {
+function operand_needs_wrap(node, parent, is_right) {
 	if (node.type === 'PrivateIdentifier') return false;
 
 	if (!is_right && (node.type === 'TSAsExpression' || node.type === 'TSSatisfiesExpression')) {
@@ -2383,42 +2392,46 @@ function needs_parens(node, parent, is_right) {
 		return true;
 	}
 
+	// `**` can't take a unary/await/assertion left operand: `-2 ** 2`, `await x ** 2`,
+	// `<T>x ** 2` are syntax errors
+	const unary_base_of_pow =
+		!is_right &&
+		parent.operator === '**' &&
+		(node.type === 'UnaryExpression' ||
+			node.type === 'AwaitExpression' ||
+			node.type === 'TSTypeAssertion');
+	if (unary_base_of_pow) return true;
+
 	const precedence = EXPRESSIONS_PRECEDENCE[node.type];
 	const parent_precedence = EXPRESSIONS_PRECEDENCE[parent.type];
-
-	if (precedence !== parent_precedence) {
-		// Different node types
-		return (
-			(!is_right && precedence === 15 && parent_precedence === 14 && parent.operator === '**') ||
-			precedence < parent_precedence
-		);
-	}
-
-	if (precedence !== 12 && precedence !== 14) {
-		// Not a `LogicalExpression` or `BinaryExpression`
-		return false;
-	}
-
-	if (
-		/** @type {TSESTree.BinaryExpression} */ (node).operator === '**' &&
-		parent.operator === '**'
-	) {
-		// Exponentiation operator has right-to-left associativity
+	if (precedence !== parent_precedence) return precedence < parent_precedence;
+	const operator = /** @type {TSESTree.BinaryExpression} */ (node).operator;
+	if (operator === '**' && parent.operator === '**') {
+		// exponentiation is right-associative
 		return !is_right;
 	}
 
 	if (is_right) {
-		// Parenthesis are used if both operators have the same precedence
-		return (
-			OPERATOR_PRECEDENCE[/** @type {TSESTree.BinaryExpression} */ (node).operator] <=
-			OPERATOR_PRECEDENCE[parent.operator]
-		);
+		// parentheses are needed when both operators have the same precedence
+		return OPERATOR_PRECEDENCE[operator] <= OPERATOR_PRECEDENCE[parent.operator];
 	}
 
-	return (
-		OPERATOR_PRECEDENCE[/** @type {TSESTree.BinaryExpression} */ (node).operator] <
-		OPERATOR_PRECEDENCE[parent.operator]
-	);
+	return OPERATOR_PRECEDENCE[operator] < OPERATOR_PRECEDENCE[parent.operator];
+}
+
+/**
+ * @param {Context} context
+ * @param {TSESTree.Node} node
+ * @param {boolean} wrap
+ */
+function maybe_wrap(context, node, wrap) {
+	if (wrap) {
+		context.write('(');
+		context.visit(node);
+		context.write(')');
+	} else {
+		context.visit(node);
+	}
 }
 
 /** @param {TSESTree.Node} node */
@@ -2432,6 +2445,96 @@ function has_call_expression(node) {
 			return false;
 		}
 	}
+	return false;
+}
+
+/**
+ * True when printing `node` as an expression statement would begin with `{`,
+ * `function`, or `class` — which the parser would misread as a block, function
+ * declaration, or class declaration. Walks the left spine following the same
+ * parenthesization the visitors apply, so it stops as soon as a child position
+ * would already be wrapped.
+ * @param {TSESTree.Node} node
+ * @returns {boolean}
+ */
+function leads_with_curly_or_keyword(node) {
+	while (node) {
+		switch (node.type) {
+			case 'ObjectExpression':
+			case 'ObjectPattern':
+			case 'FunctionExpression':
+			case 'ClassExpression':
+				return true;
+
+			case 'BinaryExpression':
+			case 'LogicalExpression':
+				if (operand_needs_wrap(node.left, node, false)) return false;
+				node = node.left;
+				continue;
+
+			case 'AssignmentExpression':
+				node = node.left;
+				continue;
+
+			case 'ConditionalExpression':
+				if (
+					EXPRESSIONS_PRECEDENCE[node.test.type] <= EXPRESSIONS_PRECEDENCE.ConditionalExpression
+				) {
+					return false;
+				}
+				node = node.test;
+				continue;
+
+			case 'MemberExpression':
+				if (
+					/** @type {string} */ (node.object.type) === 'ChainExpression' ||
+					EXPRESSIONS_PRECEDENCE[node.object.type] < EXPRESSIONS_PRECEDENCE.MemberExpression
+				) {
+					return false;
+				}
+				node = node.object;
+				continue;
+
+			case 'CallExpression':
+				if (
+					/** @type {string} */ (node.callee.type) === 'ChainExpression' ||
+					EXPRESSIONS_PRECEDENCE[node.callee.type] < EXPRESSIONS_PRECEDENCE.CallExpression
+				) {
+					return false;
+				}
+				node = node.callee;
+				continue;
+
+			case 'TaggedTemplateExpression':
+				if (
+					/** @type {string} */ (node.tag.type) === 'ChainExpression' ||
+					EXPRESSIONS_PRECEDENCE[node.tag.type] < EXPRESSIONS_PRECEDENCE.CallExpression
+				) {
+					return false;
+				}
+				node = node.tag;
+				continue;
+
+			case 'UpdateExpression':
+				if (node.prefix) return false;
+				node = node.argument;
+				continue;
+
+			case 'TSAsExpression':
+			case 'TSSatisfiesExpression':
+			case 'TSNonNullExpression':
+				node = node.expression;
+				continue;
+
+			// a sequence expression always prints its own wrapping parens
+			case 'SequenceExpression':
+				return false;
+
+			default:
+				return false;
+		}
+	}
+	return false;
 }
 
 /**