esrap 2.2.10 → 2.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esrap",
-  "version": "2.2.10",
+  "version": "2.2.12",
   "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('?.');
@@ -926,7 +908,6 @@ export default (options = {}) => {
 			}
 
 			context.write('(');
-
 			sequence(
 				context,
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
@@ -953,7 +934,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 +944,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 +992,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 +1051,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();
@@ -1240,20 +1211,13 @@ export default (options = {}) => {
 		},
 
 		ExpressionStatement(node, context) {
-			if (
+			// wrap when a leading `{`/`function` would otherwise be parsed as a block/declaration
+			const wrap =
 				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);
+				node.expression.type === 'FunctionExpression';
+			maybe_wrap(context, node.expression, wrap);
 			context.write(';');
 		},
 
@@ -1289,6 +1253,7 @@ export default (options = {}) => {
 			let name = node.name;
 			context.write(name, node);
 
+			if (node.optional) context.write('?');
 			if (node.typeAnnotation) context.visit(node.typeAnnotation);
 		},
 
@@ -1436,13 +1401,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 +1445,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 +1594,7 @@ export default (options = {}) => {
 		},
 
 		TaggedTemplateExpression(node, context) {
-			context.visit(node.tag);
+			maybe_wrap(context, node.tag, node.tag.type === 'ChainExpression');
 			context.visit(node.quasi);
 		},
 
@@ -1707,15 +1667,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) {
@@ -1951,13 +1915,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) {
@@ -2076,7 +2036,6 @@ export default (options = {}) => {
 			context.visit(node.key);
 
 			context.write('(');
-
 			sequence(
 				context,
 				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
@@ -2190,16 +2149,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);
@@ -2245,15 +2197,9 @@ export default (options = {}) => {
 
 		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 +2233,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 +2301,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 +2320,45 @@ function needs_parens(node, parent, is_right) {
 		return true;
 	}
 
+	// `**` can't take a unary/await left operand: `-2 ** 2`, `await x ** 2` are syntax errors
+	const unary_base_of_pow =
+		!is_right &&
+		parent.operator === '**' &&
+		(node.type === 'UnaryExpression' || node.type === 'AwaitExpression');
+	if (unary_base_of_pow) return true;
+
 	const precedence = EXPRESSIONS_PRECEDENCE[node.type];
 	const parent_precedence = EXPRESSIONS_PRECEDENCE[parent.type];
+	if (precedence !== parent_precedence) return precedence < parent_precedence;
 
-	if (precedence !== parent_precedence) {
-		// Different node types
-		return (
-			(!is_right && precedence === 15 && parent_precedence === 14 && parent.operator === '**') ||
-			precedence < parent_precedence
-		);
-	}
-
-	if (precedence !== 13 && precedence !== 14) {
-		// Not a `LogicalExpression` or `BinaryExpression`
-		return false;
-	}
+	const operator = /** @type {TSESTree.BinaryExpression} */ (node).operator;
 
-	if (
-		/** @type {TSESTree.BinaryExpression} */ (node).operator === '**' &&
-		parent.operator === '**'
-	) {
-		// Exponentiation operator has right-to-left associativity
+	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 +2372,7 @@ function has_call_expression(node) {
 			return false;
 		}
 	}
+	return false;
 }
 
 /**