espolar 0.2.1 → 0.3.1

package/src/printers.ts

@@ -1,90 +1,179 @@
 import type { PrinterContext, Printers } from "./api.ts";
-import type { AST, Comment } from "./types.ts";
+import type { AST, AST_NODE_TYPES, Comment } from "./types.ts";
 
-const EXPRESSIONS_PRECEDENCE: Record<string, number> = {
+const EXPRESSIONS_PRECEDENCE = {
+  // LHS of =, must NOT parenthesized
   ArrayPattern: 20,
   ObjectPattern: 20,
-  ArrayExpression: 20,
-  TaggedTemplateExpression: 20,
-  ThisExpression: 20,
-  Identifier: 20,
-  TemplateLiteral: 20,
-  Super: 20,
-  SequenceExpression: 20,
-  MemberExpression: 19,
-  MetaProperty: 19,
-  CallExpression: 19,
-  ChainExpression: 19,
-  ImportExpression: 19,
-  NewExpression: 19,
+
+  // PrimaryExpression
+  // @ts-expect-error acorn-typescript compat
+  ParenthesizedExpression: 18,
+  ThisExpression: 18,
+  Super: 18, // like ThisExpression
+  Identifier: 18,
+  PrivateIdentifier: 18, // LHS of in
   Literal: 18,
-  TSSatisfiesExpression: 18,
-  TSInstantiationExpression: 18,
-  TSNonNullExpression: 18,
-  TSTypeAssertion: 18,
-  AwaitExpression: 17,
-  ClassExpression: 17,
-  FunctionExpression: 17,
-  ObjectExpression: 17,
-  UnaryExpression: 16,
-  UpdateExpression: 16,
-  TSAsExpression: 15,
-  BinaryExpression: 14,
-  LogicalExpression: 13,
-  ConditionalExpression: 4,
-  ArrowFunctionExpression: 3,
-  AssignmentExpression: 3,
+  ClassExpression: 18,
+  FunctionExpression: 18,
+  ObjectExpression: 18,
+  ArrayExpression: 18,
+  TemplateLiteral: 18,
+  // https://react.github.io/jsx/
+  JSXElement: 18,
+  JSXFragment: 18,
+
+  MetaProperty: 17,
+  MemberExpression: 17,
+  // Same precedence as MemberExpression, e.g. foo!.bar
+  TSNonNullExpression: 17,
+  ChainExpression: 17,
+  NewExpression: 17, // only with argument list, 16 if not (we don't print this form)
+  CallExpression: 17,
+  TaggedTemplateExpression: 17,
+  ImportExpression: 17,
+  // Between MemberExpression and NewExpression w/o arguments, e.g.
+  // f<T>.x // Error
+  // (f<T>).x // OK
+  // new f<T> // OK
+  TSInstantiationExpression: 16.5,
+
+  // postfix operators
+  UpdateExpression: 15,
+  // prefix operators
+  UnaryExpression: 14,
+  AwaitExpression: 14,
+  // behaves like postfix operators (e.g. cannot be part of LHS of **)
+  TSTypeAssertion: 14,
+
+  // ranges from 13-5 depending on operator
+  BinaryExpression: 13,
+  // as/satisfies have same precedence as relational operators
+  TSAsExpression: 9,
+  TSSatisfiesExpression: 9,
+  // ranges from 4-3 depending on operator
+  LogicalExpression: 4,
+
+  AssignmentExpression: 2,
+  ConditionalExpression: 2,
   YieldExpression: 2,
-  RestElement: 1,
-};
+  ArrowFunctionExpression: 2,
+  SpreadElement: 2,
 
-const OPERATOR_PRECEDENCE: Record<string, number> = {
-  "||": 2,
-  "&&": 3,
-  "??": 4,
-  "|": 5,
-  "^": 6,
-  "&": 7,
-  "==": 8,
-  "!=": 8,
-  "===": 8,
-  "!==": 8,
+  SequenceExpression: 1,
+} as const satisfies Partial<Record<AST.Expression["type"], number>>;
+
+const OPERATOR_PRECEDENCE = {
+  "**": 13,
+  "*": 12,
+  "%": 12,
+  "/": 12,
+  "+": 11,
+  "-": 11,
+  "<<": 10,
+  ">>": 10,
+  ">>>": 10,
   "<": 9,
   ">": 9,
   "<=": 9,
   ">=": 9,
   in: 9,
   instanceof: 9,
-  "<<": 10,
-  ">>": 10,
-  ">>>": 10,
-  "+": 11,
-  "-": 11,
-  "*": 12,
-  "%": 12,
-  "/": 12,
-  "**": 13,
+  "==": 8,
+  "!=": 8,
+  "===": 8,
+  "!==": 8,
+  "&": 7,
+  "^": 6,
+  "|": 5,
+  "&&": 4,
+  "??": 3,
+  "||": 3,
+} as const satisfies Record<
+  (AST.BinaryExpression | AST.LogicalExpression)["operator"],
+  number
+>;
+
+const ASSOCIATIVE: Record<number, "left" | "right"> = {
+  [EXPRESSIONS_PRECEDENCE.MemberExpression]: "left",
+  [EXPRESSIONS_PRECEDENCE.UpdateExpression]: "left",
+  [EXPRESSIONS_PRECEDENCE.UnaryExpression]: "right",
+  [OPERATOR_PRECEDENCE["**"]]: "right",
+  [OPERATOR_PRECEDENCE["*"]]: "left",
+  [OPERATOR_PRECEDENCE["+"]]: "left",
+  [OPERATOR_PRECEDENCE["<"]]: "left",
+  [OPERATOR_PRECEDENCE["==="]]: "left",
+  [OPERATOR_PRECEDENCE["&"]]: "left",
+  [OPERATOR_PRECEDENCE["^"]]: "left",
+  [OPERATOR_PRECEDENCE["|"]]: "left",
+  [OPERATOR_PRECEDENCE["&&"]]: "left",
+  [OPERATOR_PRECEDENCE["||"]]: "left",
+  [EXPRESSIONS_PRECEDENCE.AssignmentExpression]: "right",
 };
 
-function commentNeedsNewline(comment: Comment): boolean {
-  if (comment.type === "Line") return true;
-  return comment.value.includes("\n");
-}
-
-function needsParens(
+function getPrecedence(node: AST.Expression | AST.PrivateIdentifier): number {
+  if (node.type === "BinaryExpression" || node.type === "LogicalExpression") {
+    return (
+      OPERATOR_PRECEDENCE[node.operator] ?? EXPRESSIONS_PRECEDENCE[node.type]
+    );
+  }
+  return EXPRESSIONS_PRECEDENCE[node.type] ?? 20;
+}
+
+type ExpressionWithPrecedence = keyof typeof EXPRESSIONS_PRECEDENCE;
+type ExpressionTypeWithPrecedenceAs<T extends number> = {
+  [K in AST_NODE_TYPES]: K extends ExpressionWithPrecedence
+    ? (typeof EXPRESSIONS_PRECEDENCE)[K] extends T
+      ? K
+      : never
+    : never;
+}[AST_NODE_TYPES];
+
+// Expression with same precedence as MemberExpression
+type MemberLikeExpression = Extract<
+  AST.Expression,
+  {
+    type: ExpressionTypeWithPrecedenceAs<
+      typeof EXPRESSIONS_PRECEDENCE.MemberExpression
+    >;
+  }
+>;
+
+/**
+ * Check whether the operand of a Binary/Logical/AssignmentExpression needs parentheses.
+ * @param node
+ * @param parent
+ * @param where
+ * @returns
+ */
+function operandOfBinaryExprNeedsParens(
   node: AST.Expression | AST.PrivateIdentifier,
   parent:
+    | AST.MemberExpression
+    | AST.CallExpression
+    | AST.NewExpression
+    | AST.TaggedTemplateExpression
+    | AST.TSInstantiationExpression
+    | AST.TSNonNullExpression
+    | AST.TSAsExpression
+    | AST.TSSatisfiesExpression
     | AST.BinaryExpression
     | AST.LogicalExpression
-    | AST.AssignmentExpression,
-  isRight: boolean,
+    | AST.AssignmentExpression
+    | AST.ConditionalExpression,
+  where: "left" | "right",
 ): boolean {
+  // In a BinaryExpression where LHS have a TS postfix, e.g.:
+  //   (0 as number) & 1;
+  //   (0 as number) | 1;
+  // If op is & or |, then LHS should be parenthesized to disambiguate;
+  // otherwise, no need to parenthesize.
   if (
-    node.type === "PrivateIdentifier" ||
-    node.type === "Identifier" ||
-    node.type === "Super"
+    where === "left" &&
+    (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") &&
+    parent.type === "BinaryExpression"
   ) {
-    return false;
+    return parent.operator === "&" || parent.operator === "|";
   }
 
   // LogicalExpression mixed with ?? requires parens
@@ -96,62 +185,93 @@ function needsParens(
     return true;
   }
 
-  const precedence = EXPRESSIONS_PRECEDENCE[node.type] ?? 20;
-  const parentPrecedence = EXPRESSIONS_PRECEDENCE[parent.type] ?? 20;
+  const precedence = getPrecedence(node);
+  const parentPrecedence = getPrecedence(parent);
+
+  if (
+    parent.type === "BinaryExpression" &&
+    parent.operator === "**" &&
+    precedence === EXPRESSIONS_PRECEDENCE.UnaryExpression
+  ) {
+    // LHS of ** cannot have prefix operators, according to ES spec.
+    return true;
+  }
 
   if (precedence !== parentPrecedence) {
-    // ** is right-to-left associative: `a ** b ** c` => `a ** (b ** c)`
-    if (
-      !isRight &&
-      precedence === 15 &&
-      parentPrecedence === 14 &&
-      parent.operator === "**"
-    ) {
-      return false;
-    }
     return precedence < parentPrecedence;
   }
 
-  if (precedence !== 13 && precedence !== 14) {
-    return false;
+  // optional chain cannot appeared as LHS of MemberExpression-like
+  if (
+    precedence === EXPRESSIONS_PRECEDENCE.MemberExpression &&
+    node.type === "ChainExpression"
+  ) {
+    return true;
   }
-
-  const nodeOp = (node as AST.BinaryExpression | AST.LogicalExpression)
-    .operator;
-  if (nodeOp === "**" && parent.operator === "**") {
-    return !isRight;
+  if (
+    parent.type === "NewExpression" &&
+    !validUnparenthesizedNewOperand(node as MemberLikeExpression)
+  ) {
+    // new X(), X cannot contain CallExpression
+    return true;
   }
 
-  if (isRight) {
-    return OPERATOR_PRECEDENCE[nodeOp] <= OPERATOR_PRECEDENCE[parent.operator];
-  }
-  return OPERATOR_PRECEDENCE[nodeOp] < OPERATOR_PRECEDENCE[parent.operator];
+  const associative = ASSOCIATIVE[precedence] ?? "left";
+  return associative !== where;
 }
 
-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:
+/**
+ * A valid unparenthesized `new` operand must be a member chain
+ * 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") {
       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 {
+      return true;
+    }
   }
 }
 
+function operandOfUnaryExprNeedsParens(node: AST.Expression): boolean {
+  return (
+    EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression
+  );
+}
+
+export function expectAssignmentExprNeedsParen(
+  node: AST.Expression | AST.SpreadElement,
+): boolean {
+  return (
+    EXPRESSIONS_PRECEDENCE[node.type] <
+    EXPRESSIONS_PRECEDENCE.AssignmentExpression
+  );
+}
+
+export function expectLHSExprNeedsParen(
+  node: AST.Expression | AST.SpreadElement,
+): boolean {
+  return (
+    EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.MemberExpression
+  );
+}
+
+function commentNeedsNewline(comment: Comment): boolean {
+  if (comment.type === "Line") return true;
+  return comment.value.includes("\n");
+}
+
 // Printers
 export const defaultPrinters = {
   Program: printProgram,
@@ -306,7 +426,57 @@ export const defaultPrinters = {
 // JS – Statements
 
 function printProgram(program: AST.Program, context: PrinterContext): void {
-  context.writeNodeListWithSourceGaps(program.body, "\n");
+  context.writeNodeListWithNewLineSep(program.body);
+}
+
+function canStartExpressionStatement(
+  node: AST.Expression | AST.PrivateIdentifier,
+): boolean {
+  let lhs: AST.Expression | AST.PrivateIdentifier;
+  switch (node.type) {
+    default:
+      return true;
+    case "ObjectExpression":
+    case "FunctionExpression":
+    case "ClassExpression":
+    case "ObjectPattern":
+      return false;
+    case "AssignmentExpression":
+    case "LogicalExpression":
+    case "BinaryExpression":
+      lhs = node.left;
+      break;
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      lhs = node.expression;
+      break;
+    case "CallExpression":
+      lhs = node.callee;
+      break;
+    case "MemberExpression":
+      lhs = node.object;
+      if (node.computed && lhs.type === "Identifier" && lhs.name === "let") {
+        return false;
+      }
+      break;
+    case "TaggedTemplateExpression":
+      lhs = node.tag;
+      break;
+    case "ConditionalExpression":
+      lhs = node.test;
+      break;
+    case "SequenceExpression":
+      return canStartExpressionStatement(node.expressions[0]);
+    case "UpdateExpression":
+      return canStartExpressionStatement(node.argument);
+    case "ChainExpression":
+      return canStartExpressionStatement(node.expression);
+  }
+  return (
+    operandOfBinaryExprNeedsParens(lhs, node, "left") ||
+    canStartExpressionStatement(lhs)
+  );
 }
 
 function printExpressionStatement(
@@ -314,11 +484,7 @@ function printExpressionStatement(
   context: PrinterContext,
 ): void {
   const expr = statement.expression;
-  if (
-    expr.type === "ObjectExpression" ||
-    expr.type === "FunctionExpression" ||
-    (expr.type === "AssignmentExpression" && expr.left.type === "ObjectPattern")
-  ) {
+  if (!canStartExpressionStatement(expr)) {
     context.write("(");
     context.writeNode(expr);
     context.write(");");
@@ -358,7 +524,14 @@ function printVariableDeclarator(
   }
   if (declarator.init) {
     context.write(" = ");
-    context.writeNode(declarator.init);
+    const needsParens = expectAssignmentExprNeedsParen(declarator.init);
+    if (needsParens) {
+      context.write("(");
+      context.writeNode(declarator.init);
+      context.write(")");
+    } else {
+      context.writeNode(declarator.init);
+    }
   }
 }
 
@@ -370,7 +543,7 @@ function printBlockStatement(
   context.write("{");
   if (body.length > 0) {
     context.write("\n");
-    context.writeNodeListWithSourceGaps(body, "\n");
+    context.writeNodeListWithNewLineSep(body);
     context.write("\n");
   }
   context.write("}");
@@ -660,12 +833,21 @@ function printUnaryExpression(
   if (expr.operator.length > 1) {
     context.write(" ");
   }
-  const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
-  if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.UnaryExpression) {
+  const needsParen = operandOfUnaryExprNeedsParens(expr.argument);
+  if (needsParen) {
     context.write("(");
     context.writeNode(expr.argument);
     context.write(")");
   } else {
+    if (
+      expr.operator.length === 1 &&
+      (expr.argument.type === "UnaryExpression" ||
+        expr.argument.type === "UpdateExpression") &&
+      expr.argument.operator.startsWith(expr.operator)
+    ) {
+      // `- -x` or `+ ++x` should not be printed as `--x` or `+++x`
+      context.write(" ");
+    }
     context.writeNode(expr.argument);
   }
 }
@@ -704,7 +886,7 @@ function printBinaryExpression(
   const left = expression.left;
   const right = expression.right;
 
-  if (needsParens(left, expression, false)) {
+  if (operandOfBinaryExprNeedsParens(left, expression, "left")) {
     context.write("(");
     context.writeNode(left);
     context.write(")");
@@ -716,7 +898,7 @@ function printBinaryExpression(
   context.write(String(expression.operator));
   context.write(" ");
 
-  if (needsParens(right, expression, true)) {
+  if (operandOfBinaryExprNeedsParens(right, expression, "right")) {
     context.write("(");
     context.writeNode(right);
     context.write(")");
@@ -729,8 +911,7 @@ function printConditionalExpression(
   expr: AST.ConditionalExpression,
   context: PrinterContext,
 ): void {
-  const testPrec = EXPRESSIONS_PRECEDENCE[expr.test.type] ?? 20;
-  if (testPrec <= EXPRESSIONS_PRECEDENCE.ConditionalExpression) {
+  if (operandOfBinaryExprNeedsParens(expr.test, expr, "left")) {
     context.write("(");
     context.writeNode(expr.test);
     context.write(")");
@@ -740,7 +921,13 @@ function printConditionalExpression(
   context.write(" ? ");
   context.writeNode(expr.consequent);
   context.write(" : ");
-  context.writeNode(expr.alternate);
+  if (operandOfBinaryExprNeedsParens(expr.alternate, expr, "right")) {
+    context.write("(");
+    context.writeNode(expr.alternate);
+    context.write(")");
+  } else {
+    context.writeNode(expr.alternate);
+  }
 }
 
 function printYieldExpression(
@@ -753,12 +940,14 @@ function printYieldExpression(
     const leadingComments = context.options.getLeadingComments?.(expr.argument);
     const needsParensASi =
       leadingComments?.some((c) => commentNeedsNewline(c)) ?? false;
-    if (needsParensASi) {
+    const needsParens =
+      needsParensASi || expectAssignmentExprNeedsParen(expr.argument);
+    if (needsParens) {
       context.write("(");
-    }
-    context.writeNode(expr.argument);
-    if (needsParensASi) {
+      context.writeNode(expr.argument);
       context.write(")");
+    } else {
+      context.writeNode(expr.argument);
     }
   }
 }
@@ -769,8 +958,8 @@ function printAwaitExpression(
 ): void {
   context.write("await");
   if (expr.argument) {
-    const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
-    if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.AwaitExpression) {
+    const needsParens = operandOfUnaryExprNeedsParens(expr.argument);
+    if (needsParens) {
       context.write(" (");
       context.writeNode(expr.argument);
       context.write(")");
@@ -785,17 +974,19 @@ function printSequenceExpression(
   expr: AST.SequenceExpression,
   context: PrinterContext,
 ): void {
-  context.write("(");
   context.writeNodeList(expr.expressions, ", ");
-  context.write(")");
 }
 
 function printCallExpression(
   expression: AST.CallExpression,
   context: PrinterContext,
 ): void {
-  const calleePrec = EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20;
-  if (calleePrec < EXPRESSIONS_PRECEDENCE.CallExpression) {
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.callee,
+    expression,
+    "left",
+  );
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.callee);
     context.write(")");
@@ -815,7 +1006,7 @@ function printCallExpression(
   } else {
     context.write("(");
   }
-  context.writeNodeList(expression.arguments, ", ");
+  context.writeExpressionListWithCommaSep(expression.arguments);
   context.write(")");
 }
 
@@ -824,11 +1015,12 @@ function printNewExpression(
   context: PrinterContext,
 ): void {
   context.write("new ");
-  const calleePrec = EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20;
-  if (
-    calleePrec < EXPRESSIONS_PRECEDENCE.NewExpression ||
-    hasCallExpression(expression.callee)
-  ) {
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.callee,
+    expression,
+    "left",
+  );
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.callee);
     context.write(")");
@@ -845,23 +1037,10 @@ function printNewExpression(
   } else {
     context.write("(");
   }
-  context.writeNodeList(expression.arguments, ", ");
+  context.writeExpressionListWithCommaSep(expression.arguments);
   context.write(")");
 }
 
-function hasCallExpression(node: AST.Expression): boolean {
-  let cur: AST.Expression | undefined = node;
-  while (cur) {
-    if (cur.type === "CallExpression") return true;
-    if (cur.type === "MemberExpression") {
-      cur = cur.object;
-    } else {
-      return false;
-    }
-  }
-  return false;
-}
-
 function printChainExpression(
   expression: AST.ChainExpression,
   context: PrinterContext,
@@ -873,8 +1052,12 @@ function printMemberExpression(
   expression: AST.MemberExpression,
   context: PrinterContext,
 ): void {
-  const objPrec = EXPRESSIONS_PRECEDENCE[expression.object.type] ?? 20;
-  if (objPrec < EXPRESSIONS_PRECEDENCE.MemberExpression) {
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.object,
+    expression,
+    "left",
+  );
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.object);
     context.write(")");
@@ -915,7 +1098,7 @@ function printArrayExpression(
   context: PrinterContext,
 ): void {
   context.write("[");
-  context.writeNodeList(array.elements, ", ");
+  context.writeExpressionListWithCommaSep(array.elements);
   context.write("]");
 }
 
@@ -950,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 + " ");
       }
@@ -981,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(": ");
     }
@@ -996,7 +1179,14 @@ function printSpreadElement(
   context: PrinterContext,
 ): void {
   context.write("...");
-  context.writeNode(spread.argument);
+  const needsParens = expectAssignmentExprNeedsParen(spread.argument);
+  if (needsParens) {
+    context.write("(");
+    context.writeNode(spread.argument);
+    context.write(")");
+  } else {
+    context.writeNode(spread.argument);
+  }
 }
 
 function printRestElement(
@@ -1037,7 +1227,17 @@ function printTaggedTemplateExpression(
   node: AST.TaggedTemplateExpression,
   context: PrinterContext,
 ): void {
-  context.writeNode(node.tag);
+  const needsParens = operandOfBinaryExprNeedsParens(node.tag, node, "left");
+  if (needsParens) {
+    context.write("(");
+    context.writeNode(node.tag);
+    context.write(")");
+  } else {
+    context.writeNode(node.tag);
+  }
+  if (node.typeArguments) {
+    context.writeNode(node.typeArguments);
+  }
   context.writeNode(node.quasi);
 }
 
@@ -1114,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,
@@ -1130,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(")");
@@ -1175,7 +1429,14 @@ function printClass(
   }
   if (node.superClass) {
     context.write("extends ");
-    context.writeNode(node.superClass);
+    const needsParens = expectLHSExprNeedsParen(node.superClass);
+    if (needsParens) {
+      context.write("(");
+      context.writeNode(node.superClass);
+      context.write(")");
+    } else {
+      context.writeNode(node.superClass);
+    }
     if (node.superTypeArguments) {
       context.writeNode(node.superTypeArguments);
     } else if (node.superTypeParameters) {
@@ -1197,7 +1458,7 @@ function printClassBody(node: AST.ClassBody, context: PrinterContext): void {
   const body = node.body;
   if (body.length > 0) {
     context.write("\n");
-    context.writeNodeListWithSourceGaps(body, "\n");
+    context.writeNodeListWithNewLineSep(body);
     context.write("\n");
   }
   context.write("}");
@@ -1211,15 +1472,43 @@ function printStaticBlock(
   const body = node.body;
   if (body.length > 0) {
     context.write("\n");
-    context.writeNodeListWithSourceGaps(body, "\n");
+    context.writeNodeListWithNewLineSep(body);
     context.write("\n");
   }
   context.write("}");
 }
 
+function validUnparenthesizedDecorator(node: AST.Expression): boolean {
+  let current: AST.Expression = node;
+  if (current.type === "CallExpression") {
+    current = current.callee;
+  }
+  if (current.type === "TSInstantiationExpression") {
+    current = current.expression;
+  }
+  while (true) {
+    if (current.type === "Identifier") {
+      return true;
+    } else if (current.type === "MemberExpression") {
+      if (current.computed) {
+        return false;
+      }
+      current = current.object;
+    } else {
+      return false;
+    }
+  }
+}
+
 function printDecorator(node: AST.Decorator, context: PrinterContext): void {
   context.write("@");
-  context.writeNode(node.expression);
+  if (!validUnparenthesizedDecorator(node.expression)) {
+    context.write("(");
+    context.writeNode(node.expression);
+    context.write(")");
+  } else {
+    context.writeNode(node.expression);
+  }
   context.write("\n");
 }
 
@@ -1375,13 +1664,17 @@ function printImportDeclaration(
   }
 
   if (namespaceSpec) {
-    if (wroteDefault) context.write(", ");
+    if (wroteDefault) {
+      context.write(", ");
+    }
     context.write("* as ");
     context.writeNode(namespaceSpec.local);
   }
 
   if (namedSpecs.length > 0) {
-    if (wroteDefault || namespaceSpec) context.write(", ");
+    if (wroteDefault || namespaceSpec) {
+      context.write(", ");
+    }
     context.write("{ ");
     context.writeNodeList(namedSpecs, ", ");
     context.write(" }");
@@ -1546,8 +1839,12 @@ function printTSAsExpression(
   expression: AST.TSAsExpression,
   context: PrinterContext,
 ): void {
-  const exprPrec = EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20;
-  if (exprPrec < EXPRESSIONS_PRECEDENCE.TSAsExpression) {
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.expression,
+    expression,
+    "left",
+  );
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.expression);
     context.write(")");
@@ -1562,8 +1859,12 @@ function printTSSatisfiesExpression(
   expression: AST.TSSatisfiesExpression,
   context: PrinterContext,
 ): void {
-  const exprPrec = EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20;
-  if (exprPrec < EXPRESSIONS_PRECEDENCE.TSSatisfiesExpression) {
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.expression,
+    expression,
+    "left",
+  );
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.expression);
     context.write(")");
@@ -1581,8 +1882,8 @@ function printTSTypeAssertion(
   context.write("<");
   context.writeNode(expression.typeAnnotation);
   context.write(">");
-  const exprPrec = EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20;
-  if (exprPrec < EXPRESSIONS_PRECEDENCE.TSTypeAssertion) {
+  const needsParens = operandOfUnaryExprNeedsParens(expression.expression);
+  if (needsParens) {
     context.write("(");
     context.writeNode(expression.expression);
     context.write(")");
@@ -1595,7 +1896,18 @@ function printTSNonNullExpression(
   expression: AST.TSNonNullExpression,
   context: PrinterContext,
 ): void {
-  context.writeNode(expression.expression);
+  const needsParens = operandOfBinaryExprNeedsParens(
+    expression.expression,
+    expression,
+    "left",
+  );
+  if (needsParens) {
+    context.write("(");
+    context.writeNode(expression.expression);
+    context.write(")");
+  } else {
+    context.writeNode(expression.expression);
+  }
   context.write("!");
 }
 
@@ -1991,7 +2303,14 @@ function printTSMappedType(
   node: AST.TSMappedType,
   context: PrinterContext,
 ): void {
-  context.write("{ [");
+  context.write("{ ");
+  if (node.readonly) {
+    if (typeof node.readonly === "string") {
+      context.write(node.readonly);
+    }
+    context.write("readonly ");
+  }
+  context.write("[");
   const legacyTp = node.typeParameter;
   const key = node.key ?? legacyTp?.name;
   const constraint = node.constraint ?? legacyTp?.constraint;
@@ -2007,7 +2326,17 @@ function printTSMappedType(
     context.write(" in ");
     context.writeNode(constraint);
   }
+  if (node.nameType) {
+    context.write(" as ");
+    context.writeNode(node.nameType);
+  }
   context.write("]");
+  if (node.optional) {
+    if (typeof node.optional === "string") {
+      context.write(node.optional);
+    }
+    context.write("?");
+  }
   if (node.typeAnnotation) {
     context.write(": ");
     context.writeNode(node.typeAnnotation);
@@ -2164,11 +2493,18 @@ function printTSModuleDeclaration(
     context.write(String(kind) + " ");
     context.writeNode(node.id);
   }
-  if (node.body) {
-    if (node.body.type === "TSModuleBlock") {
-      context.write(" ");
-    }
-    context.writeNode(node.body);
+  let body = node.body as
+    | AST.TSModuleDeclaration
+    | AST.TSModuleBlock
+    | undefined;
+  while (body?.type === "TSModuleDeclaration") {
+    context.write(".");
+    context.writeNode(body.id);
+    body = body.body;
+  }
+  if (body) {
+    context.write(" ");
+    context.writeNode(body);
   }
 }
 
@@ -2177,7 +2513,7 @@ function printTSModuleBlock(
   context: PrinterContext,
 ): void {
   context.write("{\n");
-  context.writeNodeListWithSourceGaps(node.body, "\n");
+  context.writeNodeListWithNewLineSep(node.body);
   context.write("\n}");
 }
 
@@ -2239,10 +2575,21 @@ function printTSNamespaceExportDeclaration(
 }
 
 function printTSInstantiationExpression(
-  node: { expression: AST.Node; typeArguments: AST.Node },
+  node: AST.TSInstantiationExpression,
   context: PrinterContext,
 ): void {
-  context.writeNode(node.expression);
+  const needsParens = operandOfBinaryExprNeedsParens(
+    node.expression,
+    node,
+    "left",
+  );
+  if (needsParens) {
+    context.write("(");
+    context.writeNode(node.expression);
+    context.write(")");
+  } else {
+    context.writeNode(node.expression);
+  }
   context.writeNode(node.typeArguments);
 }
 
@@ -2274,3 +2621,14 @@ function writeOptionalTypeAnnotation(
     context.writeNode(node.typeAnnotation);
   }
 }
+
+export function writeComment(comment: Comment, context: PrinterContext): void {
+  if (comment.type === "Line") {
+    context.write("//" + comment.value + "\n");
+  } else {
+    context.write("/*" + comment.value + "*/");
+    if (comment.value.includes("\n")) {
+      context.write("\n");
+    }
+  }
+}