espolar 0.3.0 → 0.3.1

package/dist/index.js

@@ -109,13 +109,13 @@ function operandOfBinaryExprNeedsParens(node, parent, where) {
 * which not contains a CallExpression
 */
 function validUnparenthesizedNewOperand(node) {
+	if (node.type === "ChainExpression" || node.type === "ImportExpression") return false;
 	let cur = node;
 	while (true) if (cur.type === "CallExpression") return false;
 	else if (cur.type === "TSNonNullExpression") cur = cur.expression;
 	else if (cur.type === "MemberExpression") cur = cur.object;
 	else if (cur.type === "TaggedTemplateExpression") cur = cur.tag;
-	else if (cur.type === "MetaProperty" || cur.type === "NewExpression" || cur.type === "ImportExpression") return true;
-	else return cur !== node;
+	else return true;
 }
 function operandOfUnaryExprNeedsParens(node) {
 	return EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression;
@@ -130,19 +130,6 @@ function commentNeedsNewline(comment) {
 	if (comment.type === "Line") return true;
 	return comment.value.includes("\n");
 }
-function arrowConciseBodyNeedsWrap(body) {
-	if (body.type === "BlockStatement") return false;
-	switch (body.type) {
-		case "ObjectExpression": return true;
-		case "AssignmentExpression": return body.left.type === "ObjectPattern";
-		case "LogicalExpression": return body.left.type === "ObjectExpression";
-		case "ConditionalExpression": return body.test.type === "ObjectExpression";
-		case "TSAsExpression":
-		case "TSSatisfiesExpression":
-		case "TSNonNullExpression": return body.expression ? arrowConciseBodyNeedsWrap(body.expression) : false;
-		default: return false;
-	}
-}
 const defaultPrinters = {
 	Program: printProgram,
 	Identifier: printIdentifier,
@@ -312,6 +299,7 @@ function canStartExpressionStatement(node) {
 			break;
 		case "MemberExpression":
 			lhs = node.object;
+			if (node.computed && lhs.type === "Identifier" && lhs.name === "let") return false;
 			break;
 		case "TaggedTemplateExpression":
 			lhs = node.tag;
@@ -686,7 +674,7 @@ function printProperty(property, context) {
 			context.writeNode(value);
 			return;
 		}
-		if (value.type === "FunctionExpression") {
+		if (value.type === "FunctionExpression" && (property.method || property.kind !== "init")) {
 			if (property.kind !== "init") context.write(property.kind + " ");
 			if (value.async === true) context.write("async ");
 			if (value.generator === true) context.write("*");
@@ -708,7 +696,6 @@ function printProperty(property, context) {
 			context.writeNode(property.key);
 			context.write("]: ");
 		} else {
-			if (property.kind === "get" || property.kind === "set") context.write(property.kind + " ");
 			context.writeNode(property.key);
 			context.write(": ");
 		}
@@ -794,6 +781,44 @@ function printFunction(fn, context) {
 		context.writeNode(fn.body);
 	}
 }
+function canStartConciseBody(body) {
+	if (body.type === "BlockStatement" || body.type === "PrivateIdentifier") return true;
+	if (expectAssignmentExprNeedsParen(body)) return false;
+	let lhs;
+	switch (body.type) {
+		default: return true;
+		case "ObjectExpression":
+		case "FunctionExpression":
+		case "ClassExpression":
+		case "ObjectPattern": return false;
+		case "AssignmentExpression":
+		case "LogicalExpression":
+		case "BinaryExpression":
+			lhs = body.left;
+			break;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+			lhs = body.expression;
+			break;
+		case "CallExpression":
+			lhs = body.callee;
+			break;
+		case "MemberExpression":
+			lhs = body.object;
+			if (body.computed && lhs.type === "Identifier" && lhs.name === "let") return false;
+			break;
+		case "TaggedTemplateExpression":
+			lhs = body.tag;
+			break;
+		case "ConditionalExpression":
+			lhs = body.test;
+			break;
+		case "UpdateExpression": return canStartConciseBody(body.argument);
+		case "ChainExpression": return canStartConciseBody(body.expression);
+	}
+	return operandOfBinaryExprNeedsParens(lhs, body, "left") || canStartConciseBody(lhs);
+}
 function printArrowFunctionExpression(fn, context) {
 	if (fn.async === true) context.write("async ");
 	if (fn.typeParameters) context.writeNode(fn.typeParameters);
@@ -803,7 +828,7 @@ function printArrowFunctionExpression(fn, context) {
 	writeReturnType(fn, context);
 	context.write(" => ");
 	const body = fn.body;
-	if (arrowConciseBodyNeedsWrap(body)) {
+	if (!canStartConciseBody(body)) {
 		context.write("(");
 		context.writeNode(body);
 		context.write(")");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "espolar",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "exports": {

package/src/printers.ts

@@ -225,6 +225,9 @@ function operandOfBinaryExprNeedsParens(
  * which not contains a CallExpression
  */
 function validUnparenthesizedNewOperand(node: MemberLikeExpression): boolean {
+  if (node.type === "ChainExpression" || node.type === "ImportExpression") {
+    return false;
+  }
   let cur: AST.Expression = node;
   while (true) {
     if (cur.type === "CallExpression") {
@@ -235,18 +238,8 @@ function validUnparenthesizedNewOperand(node: MemberLikeExpression): boolean {
       cur = cur.object;
     } else if (cur.type === "TaggedTemplateExpression") {
       cur = cur.tag;
-    } else if (
-      cur.type === "MetaProperty" ||
-      cur.type === "NewExpression" ||
-      cur.type === "ImportExpression"
-    ) {
-      return true;
     } else {
-      // The operand is either:
-      // - an expression with higher precedence, no need to check further
-      // - an expression with lower precedence, will be inner-parenthesized later
-      // - a ChainExpression, will be inner-parenthesized later
-      return cur !== node;
+      return true;
     }
   }
 }
@@ -279,30 +272,6 @@ function commentNeedsNewline(comment: Comment): boolean {
   return comment.value.includes("\n");
 }
 
-function arrowConciseBodyNeedsWrap(
-  body: AST.BlockStatement | AST.Expression,
-): boolean {
-  if (body.type === "BlockStatement") return false;
-  switch (body.type) {
-    case "ObjectExpression":
-      return true;
-    case "AssignmentExpression":
-      return body.left.type === "ObjectPattern";
-    case "LogicalExpression":
-      return body.left.type === "ObjectExpression";
-    case "ConditionalExpression":
-      return body.test.type === "ObjectExpression";
-    case "TSAsExpression":
-    case "TSSatisfiesExpression":
-    case "TSNonNullExpression":
-      return body.expression
-        ? arrowConciseBodyNeedsWrap(body.expression)
-        : false;
-    default:
-      return false;
-  }
-}
-
 // Printers
 export const defaultPrinters = {
   Program: printProgram,
@@ -487,6 +456,9 @@ function canStartExpressionStatement(
       break;
     case "MemberExpression":
       lhs = node.object;
+      if (node.computed && lhs.type === "Identifier" && lhs.name === "let") {
+        return false;
+      }
       break;
     case "TaggedTemplateExpression":
       lhs = node.tag;
@@ -1161,7 +1133,10 @@ function printProperty(
     }
 
     // shorthand method
-    if (value.type === "FunctionExpression") {
+    if (
+      value.type === "FunctionExpression" &&
+      (property.method || property.kind !== "init")
+    ) {
       if (property.kind !== "init") {
         context.write(property.kind + " ");
       }
@@ -1192,9 +1167,6 @@ function printProperty(
       context.writeNode(property.key);
       context.write("]: ");
     } else {
-      if (property.kind === "get" || property.kind === "set") {
-        context.write(property.kind + " ");
-      }
       context.writeNode(property.key);
       context.write(": ");
     }
@@ -1342,6 +1314,60 @@ function printFunction(
   }
 }
 
+function canStartConciseBody(
+  body: AST.BlockStatement | AST.Expression | AST.PrivateIdentifier,
+): boolean {
+  if (body.type === "BlockStatement" || body.type === "PrivateIdentifier") {
+    return true;
+  }
+  if (expectAssignmentExprNeedsParen(body)) {
+    return false;
+  }
+  let lhs: AST.Expression | AST.PrivateIdentifier;
+  switch (body.type) {
+    default:
+      return true;
+    case "ObjectExpression":
+    case "FunctionExpression":
+    case "ClassExpression":
+    case "ObjectPattern":
+      return false;
+    case "AssignmentExpression":
+    case "LogicalExpression":
+    case "BinaryExpression":
+      lhs = body.left;
+      break;
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      lhs = body.expression;
+      break;
+    case "CallExpression":
+      lhs = body.callee;
+      break;
+    case "MemberExpression":
+      lhs = body.object;
+      if (body.computed && lhs.type === "Identifier" && lhs.name === "let") {
+        return false;
+      }
+      break;
+    case "TaggedTemplateExpression":
+      lhs = body.tag;
+      break;
+    case "ConditionalExpression":
+      lhs = body.test;
+      break;
+    case "UpdateExpression":
+      return canStartConciseBody(body.argument);
+    case "ChainExpression":
+      return canStartConciseBody(body.expression);
+  }
+  return (
+    operandOfBinaryExprNeedsParens(lhs, body, "left") ||
+    canStartConciseBody(lhs)
+  );
+}
+
 function printArrowFunctionExpression(
   fn: AST.ArrowFunctionExpression,
   context: PrinterContext,
@@ -1358,7 +1384,7 @@ function printArrowFunctionExpression(
   writeReturnType(fn, context);
   context.write(" => ");
   const body = fn.body;
-  if (arrowConciseBodyNeedsWrap(body)) {
+  if (!canStartConciseBody(body)) {
     context.write("(");
     context.writeNode(body);
     context.write(")");