Matching Prettier's binary operation grouping and indentation

Author: Janther

src/binary-operator-printers/addition.js

@@ -0,0 +1,8 @@
+import { defaultBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+
+export const addition = {
+  match: (op) => ['+', '-'].includes(op),
+  print: defaultBinaryOperationPrinter
+  // grouping and indenting before `bit` and `shift` should technically be here
+  // but they are properly parenthesised before reaching this point.
+};

src/binary-operator-printers/arithmetic.js

@@ -1,6 +1,6 @@
-import { arithmetic } from './arithmetic.js';
+import { defaultBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
 
 export const bit = {
   match: (op) => ['&', '|', '^'].includes(op),
-  print: arithmetic.print
+  print: defaultBinaryOperationPrinter
 };

src/binary-operator-printers/bit.js

@@ -1,19 +1,24 @@
 import { doc } from 'prettier';
+import {
+  createBinaryOperationPrinter,
+  createIndentIfNecessaryBuilder
+} from './printers/create-binary-operation-printer.js';
+import { addition } from './addition.js';
+import { multiplication } from './multiplication.js';
 
-const { group, indent, line } = doc.builders;
+const { group } = doc.builders;
+
+const exponentiationPrinter = createBinaryOperationPrinter(
+  () => (document) => group(document), // always group
+  createIndentIfNecessaryBuilder([
+    addition,
+    multiplication
+    // `bit` and `shift` should technically be here but they are properly
+    // parenthesised before reaching this point.
+  ])
+);
 
 export const exponentiation = {
   match: (op) => op === '**',
-  print: (node, path, print) => {
-    const right = [' ', node.operator, line, path.call(print, 'right')];
-    // If it's a single binary operation, avoid having a small right
-    // operand like - 1 on its own line
-    const shouldGroup =
-      node.left.type !== 'BinaryOperation' &&
-      path.getParentNode().type !== 'BinaryOperation';
-    return group([
-      path.call(print, 'left'),
-      indent(shouldGroup ? group(right) : right)
-    ]);
-  }
+  print: exponentiationPrinter
 };

src/binary-operator-printers/exponentiation.js

@@ -1,7 +1,8 @@
-export * from './arithmetic.js';
+export * from './addition.js';
 export * from './assignment.js';
 export * from './bit.js';
 export * from './comparison.js';
 export * from './exponentiation.js';
 export * from './logical.js';
+export * from './multiplication.js';
 export * from './shift.js';

src/binary-operator-printers/index.js

@@ -0,0 +1,20 @@
+import {
+  createBinaryOperationPrinter,
+  createGroupIfNecessaryBuilder,
+  createIndentIfNecessaryBuilder
+} from './printers/create-binary-operation-printer.js';
+import { addition } from './addition.js';
+import { bit } from './bit.js';
+import { shift } from './shift.js';
+
+const matchers = [addition, bit, shift];
+
+const multiplicationPrinter = createBinaryOperationPrinter(
+  createGroupIfNecessaryBuilder(matchers),
+  createIndentIfNecessaryBuilder(matchers)
+);
+
+export const multiplication = {
+  match: (op) => ['*', '/', '%'].includes(op),
+  print: multiplicationPrinter
+};

src/binary-operator-printers/multiplication.js

@@ -0,0 +1,64 @@
+import { doc } from 'prettier';
+import { assignment } from '../assignment.js';
+import { comparison } from '../comparison.js';
+
+const { group, indent, line } = doc.builders;
+
+const shouldGroupOrIndent = (node, matchers) =>
+  matchers.some((matcher) => matcher.match(node.operator));
+
+export const createGroupIfNecessaryBuilder =
+  (matchers) => (path) => (document) => {
+    const parentNode = path.getParentNode();
+    if (
+      parentNode.type === 'BinaryOperation' &&
+      !comparison.match(parentNode.operator)
+    ) {
+      return shouldGroupOrIndent(parentNode, matchers)
+        ? group(document)
+        : document;
+    }
+    return group(document);
+  };
+
+export const createIndentIfNecessaryBuilder =
+  (matchers) => (path) => (document) => {
+    let node = path.getNode();
+    for (let i = 0; ; i += 1) {
+      const parentNode = path.getParentNode(i);
+      if (parentNode.type === 'ReturnStatement') return document;
+      if (
+        parentNode.type !== 'BinaryOperation' ||
+        comparison.match(parentNode.operator) ||
+        shouldGroupOrIndent(parentNode, matchers)
+      ) {
+        return indent(document);
+      }
+      if (node === parentNode.right) return document;
+      node = parentNode;
+    }
+  };
+
+export const createBinaryOperationPrinter =
+  (groupIfNecessaryBuilder, indentIfNecessaryBuilder) =>
+  (node, path, print) => {
+    const groupIfNecessary = groupIfNecessaryBuilder(path);
+    const indentIfNecessary = indentIfNecessaryBuilder(path);
+
+    const right = [' ', node.operator, line, path.call(print, 'right')];
+    // If it's a single binary operation, avoid having a small right
+    // operand like - 1 on its own line
+    const parent = path.getParentNode();
+    const shouldGroup =
+      node.left.type !== 'BinaryOperation' &&
+      (parent.type !== 'BinaryOperation' || assignment.match(parent.operator));
+    return groupIfNecessary([
+      path.call(print, 'left'),
+      indentIfNecessary(shouldGroup ? group(right) : right)
+    ]);
+  };
+
+export const defaultBinaryOperationPrinter = createBinaryOperationPrinter(
+  createGroupIfNecessaryBuilder([]),
+  createIndentIfNecessaryBuilder([])
+);

src/binary-operator-printers/printers/create-binary-operation-printer.js

@@ -1,6 +1,8 @@
-import { arithmetic } from './arithmetic.js';
+import { defaultBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
 
 export const shift = {
   match: (op) => ['<<', '>>'].includes(op),
-  print: arithmetic.print
+  print: defaultBinaryOperationPrinter
+  // grouping and indenting before `bit` should technically be here but they
+  // are properly parenthesised before reaching this point.
 };