MOD: binaryish

Author: lehni

cspell.json

@@ -224,6 +224,8 @@
         "posix",
         "precache",
         "preorder",
+        "preprocess",
+        "prerun",
         "prettierx",
         "progid",
         "Pschera",

src/document/printer.js

@@ -697,7 +697,49 @@ function printDocToString(doc, options) {
     };
   }
 
-  return { formatted: out.join("") };
+  // MOD: Pull dangling opening parenthesis and empty object, array and string
+  // literals after binaryish operators followed by newlines up to the previous
+  // line.
+  const binaryishExp = new RegExp(
+    `(${binaryishOperators})${newLine}\\s*((?:\\(|(?:\\{\\}|\\[\\]|['"\`]{2})[);]*)${newLine})`,
+    "g"
+  );
+  const formatted = out.join("").replace(binaryishExp, "$1 $2");
+
+  return { formatted };
 }
 
+const binaryishOperators = [
+  // LogicalOperator
+  "&&",
+  "||",
+  "??",
+
+  // BinaryOperator
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "<<",
+  ">>",
+  ">>>",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "&",
+  "|",
+  "^",
+  "in",
+  "instanceof",
+  "..",
+]
+  .map((operator) => `${operator.replaceAll(/[$()*+./?[\\\]^{|}-]/g, "\\$&")}`)
+  .join("|");
+
 export { printDocToString };

src/language-js/needs-parens.js

@@ -20,6 +20,7 @@ import {
   shouldFlatten,
   startsWithNoLookaheadToken,
 } from "./utils/index.js";
+import { isParenthesized } from "./utils/is-parenthesized.js";
 
 /**
  * @import AstPath from "../common/ast-path.js"
@@ -401,7 +402,11 @@ function needsParens(path, options) {
 
         case "LogicalExpression":
           if (node.type === "LogicalExpression") {
-            return parent.operator !== node.operator;
+            // MOD: Only add parens to logical expressions if the operator
+            // precedence dictates it, or if it was parenthesized in the
+            // original code.
+            // return parent.operator !== node.operator;
+            return isParenthesized(node, options);
           }
         // else fallthrough
 
@@ -431,7 +436,8 @@ function needsParens(path, options) {
           }
 
           if (parentPrecedence < precedence && operator === "%") {
-            return parentOperator === "+" || parentOperator === "-";
+          // MOD: No special treatment for modulo
+          // return parentOperator === "+" || parentOperator === "-";
           }
 
           // Add parenthesis when working with bitwise operators
@@ -440,7 +446,7 @@ function needsParens(path, options) {
             return true;
           }
 
-          return false;
+          return isParenthesized(node, options);
         }
 
         default:

src/language-js/print/angular.js

@@ -10,7 +10,7 @@ import { printBinaryishExpression } from "./binaryish.js";
 
 /** @import AstPath from "../../common/ast-path.js" */
 
-function printAngular(path, options, print) {
+function printAngular(path, options, print, args) {
   const { node } = path;
 
   // Angular nodes always starts with `NG`
@@ -27,7 +27,7 @@ function printAngular(path, options, print) {
           : "",
       ];
     case "NGPipeExpression":
-      return printBinaryishExpression(path, options, print);
+      return printBinaryishExpression(path, options, print, args);
     case "NGChainedExpression":
       return group(
         join(

src/language-js/print/arrow-function.js

@@ -149,6 +149,16 @@ function printArrowFunction(path, options, print, args = {}) {
     shouldPutBodyOnSameLine,
   });
 
+  // MOD: Wrap binaryish multi-line bodies in parens
+  if (isBinaryish(functionBody)) {
+    bodyDoc = group([
+      ifBreak(" ("),
+      bodyDoc,
+      softline,
+      ifBreak(")"),
+    ]);
+  }
+
   return group([
     group(
       shouldIndentSignatures

src/language-js/print/assignment.js

@@ -1,9 +1,13 @@
 import {
+  softline,
+  hardline,
   group,
   indent,
+  ifBreak,
   indentIfBreak,
   line,
   lineSuffixBoundary,
+  conditionalGroup,
 } from "../../document/builders.js";
 import { canBreak, cleanDoc, willBreak } from "../../document/utils.js";
 import getStringWidth from "../../utils/get-string-width.js";
@@ -20,7 +24,7 @@ import {
   isNumericLiteral,
   isObjectProperty,
   isStringLiteral,
-  isUnionType,
+  isUnionType
 } from "../utils/index.js";
 import { shouldInlineLogicalExpression } from "./binaryish.js";
 import { printCallExpression } from "./call-expression.js";
@@ -42,11 +46,23 @@ function printAssignment(
   const rightDoc = rightPropertyName
     ? print(rightPropertyName, { assignmentLayout: layout })
     : "";
+  const rightNode = path.node[rightPropertyName];
 
   switch (layout) {
     // First break after operator, then the sides are broken independently on their own lines
-    case "break-after-operator":
-      return group([group(leftDoc), operator, group(indent([line, rightDoc]))]);
+    case "break-after-operator": {
+      // // MOD: Wrap multi-line binaryish assignments in parenthesis.
+      const needsParens = isBinaryish(rightNode);
+      const rightGroup = needsParens
+        ? group([
+            ifBreak(" (", " "),
+            indent([softline, rightDoc]),
+            softline,
+            ifBreak(")"),
+          ])
+        : group(indent([line, rightDoc]));
+      return group([group(leftDoc), operator, rightGroup]);
+    }
 
     // First break right-hand side, then left-hand side
     case "never-break-after-operator":
@@ -55,13 +71,25 @@ function printAssignment(
     // First break right-hand side, then after operator
     case "fluid": {
       const groupId = Symbol("assignment");
-      return group([
+      const grouped = group([
         group(leftDoc),
         operator,
         group(indent(line), { id: groupId }),
         lineSuffixBoundary,
         indentIfBreak(rightDoc, { groupId }),
       ]);
+      // // MOD: Wrap multi-line binaryish assignments in parenthesis.
+      return isBinaryish(rightNode) &&
+        !shouldInlineLogicalExpression(path.node, path.parent, options)
+        ? conditionalGroup([
+            grouped,
+            group([
+              group(leftDoc),
+              operator,
+              group([" (", indent([hardline, rightDoc]), hardline, ")"]),
+            ]),
+          ])
+        : grouped
     }
 
     case "break-lhs":
@@ -193,7 +221,10 @@ function chooseLayout(path, options, print, leftDoc, rightPropertyName) {
 function shouldBreakAfterOperator(path, options, print, hasShortKey) {
   const rightNode = path.node;
 
-  if (isBinaryish(rightNode) && !shouldInlineLogicalExpression(rightNode)) {
+  if (
+    isBinaryish(rightNode) &&
+    !shouldInlineLogicalExpression(rightNode, path.parent, options)
+  ) {
     return true;
   }
 
@@ -213,7 +244,7 @@ function shouldBreakAfterOperator(path, options, print, hasShortKey) {
     case "ConditionalExpression": {
       if (!options.experimentalTernaries) {
         const { test } = rightNode;
-        return isBinaryish(test) && !shouldInlineLogicalExpression(test);
+        return isBinaryish(test) && !shouldInlineLogicalExpression(test, rightNode, options);
       }
       const { consequent, alternate } = rightNode;
       return (