Standardising the printers so that we can review at every level what are the binary operations that that should force grouping and indentation

Author: Janther

src/binary-operator-printers/addition.js

@@ -1,8 +1,11 @@
-import { defaultBinaryOperationPrinter } from './printers/default-binary-operation-printer.js';
+import { binaryOperationPrinter } from './printers/binary-operation-printer.js';
+import { bit } from './bit.js';
+import { shift } from './shift.js';
+import { inequality } from './inequality.js';
+import { equality } from './equality.js';
+import { logical } from './logical.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.
+  print: binaryOperationPrinter([shift, bit, inequality, equality, logical])
 };

src/binary-operator-printers/bit.js

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

src/binary-operator-printers/equality.js

@@ -1,12 +1,7 @@
-import { createGroupedBinaryOperationPrinter } from './printers/create-grouped-binary-operation-printer.js';
-import { createComparisonIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
+import { comparisonOperationPrinter } from './printers/comparison-operation-printer.js';
 import { logical } from './logical.js';
 
-const equalityPrinter = createGroupedBinaryOperationPrinter(
-  createComparisonIndentIfNecessaryBuilder([logical])
-);
-
 export const equality = {
   match: (op) => ['==', '!='].includes(op),
-  print: equalityPrinter
+  print: comparisonOperationPrinter([logical])
 };

src/binary-operator-printers/exponentiation.js

@@ -1,22 +1,28 @@
-import { createGroupedBinaryOperationPrinter } from './printers/create-grouped-binary-operation-printer.js';
-import { createArithmeticIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
+import { doc } from 'prettier';
+import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
+import { createBinaryIndentIfNecessaryBuilder } from './printers/binary-operation-printer.js';
+import { multiplication } from './multiplication.js';
 import { addition } from './addition.js';
-import { equality } from './equality.js';
+import { shift } from './shift.js';
+import { bit } from './bit.js';
 import { inequality } from './inequality.js';
-import { multiplication } from './multiplication.js';
+import { equality } from './equality.js';
+import { logical } from './logical.js';
 
-const exponentiationPrinter = createGroupedBinaryOperationPrinter(
-  createArithmeticIndentIfNecessaryBuilder([
-    addition,
-    equality,
-    inequality,
-    multiplication
-    // `bit` and `shift` should technically be here but they are properly
-    // parenthesised before reaching this point.
-  ])
-);
+const { group } = doc.builders;
 
 export const exponentiation = {
   match: (op) => op === '**',
-  print: exponentiationPrinter
+  print: createBinaryOperationPrinter(
+    () => (document) => group(document), // always group
+    createBinaryIndentIfNecessaryBuilder([
+      multiplication,
+      addition,
+      shift,
+      bit,
+      inequality,
+      equality,
+      logical
+    ])
+  )
 };

src/binary-operator-printers/inequality.js

@@ -1,13 +1,8 @@
-import { createGroupedBinaryOperationPrinter } from './printers/create-grouped-binary-operation-printer.js';
-import { createComparisonIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
+import { comparisonOperationPrinter } from './printers/comparison-operation-printer.js';
 import { logical } from './logical.js';
 import { equality } from './equality.js';
 
-const inequalityPrinter = createGroupedBinaryOperationPrinter(
-  createComparisonIndentIfNecessaryBuilder([logical, equality])
-);
-
 export const inequality = {
   match: (op) => ['<', '>', '<=', '>='].includes(op),
-  print: inequalityPrinter
+  print: comparisonOperationPrinter([logical, equality])
 };

src/binary-operator-printers/logical.js

@@ -23,12 +23,10 @@ const indentIfNecessaryBuilder = (path, options) => (document) => {
   }
 };
 
-const logicalPrinter = createBinaryOperationPrinter(
-  createGroupIfNecessaryBuilder([]),
-  indentIfNecessaryBuilder
-);
-
 export const logical = {
   match: (op) => ['&&', '||'].includes(op),
-  print: logicalPrinter
+  print: createBinaryOperationPrinter(
+    createGroupIfNecessaryBuilder([]),
+    indentIfNecessaryBuilder
+  )
 };

src/binary-operator-printers/multiplication.js

@@ -1,20 +1,19 @@
-import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js';
-import { createGroupIfNecessaryBuilder } from './printers/create-group-if-necessary-builder.js';
-import { createArithmeticIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js';
+import { binaryOperationPrinter } from './printers/binary-operation-printer.js';
 import { addition } from './addition.js';
 import { bit } from './bit.js';
 import { equality } from './equality.js';
 import { inequality } from './inequality.js';
 import { shift } from './shift.js';
-
-const matchers = [addition, bit, equality, inequality, shift];
-
-const multiplicationPrinter = createBinaryOperationPrinter(
-  createGroupIfNecessaryBuilder(matchers),
-  createArithmeticIndentIfNecessaryBuilder(matchers)
-);
+import { logical } from './logical.js';
 
 export const multiplication = {
   match: (op) => ['*', '/', '%'].includes(op),
-  print: multiplicationPrinter
+  print: binaryOperationPrinter([
+    addition,
+    shift,
+    bit,
+    inequality,
+    equality,
+    logical
+  ])
 };

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

@@ -0,0 +1,12 @@
+import { createBinaryOperationPrinter } from './create-binary-operation-printer.js';
+import { createGroupIfNecessaryBuilder } from './create-group-if-necessary-builder.js';
+import { createIndentIfNecessaryBuilder } from './create-indent-if-necessary-builder.js';
+
+export const createBinaryIndentIfNecessaryBuilder =
+  createIndentIfNecessaryBuilder(['ReturnStatement']);
+
+export const binaryOperationPrinter = (shouldGroupAndIndentMatchers) =>
+  createBinaryOperationPrinter(
+    createGroupIfNecessaryBuilder(shouldGroupAndIndentMatchers),
+    createBinaryIndentIfNecessaryBuilder(shouldGroupAndIndentMatchers)
+  );

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

@@ -0,0 +1,12 @@
+import { createBinaryOperationPrinter } from './create-binary-operation-printer.js';
+import { createGroupIfNecessaryBuilder } from './create-group-if-necessary-builder.js';
+import { createIndentIfNecessaryBuilder } from './create-indent-if-necessary-builder.js';
+
+const createComparisonIndentIfNecessaryBuilder = createIndentIfNecessaryBuilder(
+  ['ReturnStatement', 'IfStatement', 'ForStatement', 'WhileStatement']
+);
+export const comparisonOperationPrinter = (shouldGroupAndIndentMatchers) =>
+  createBinaryOperationPrinter(
+    createGroupIfNecessaryBuilder(shouldGroupAndIndentMatchers),
+    createComparisonIndentIfNecessaryBuilder(shouldGroupAndIndentMatchers)
+  );

src/binary-operator-printers/printers/create-group-if-necessary-builder.js

@@ -4,8 +4,9 @@ import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js';
 const { group } = doc.builders;
 
 export const createGroupIfNecessaryBuilder =
-  (matchers) => (path) => (document) => {
+  (shouldIndentMatchers) => (path) => (document) => {
     const parentNode = path.getParentNode();
-    if (shouldGroupOrIndent(parentNode, matchers)) return group(document);
+    if (shouldGroupOrIndent(parentNode, shouldIndentMatchers))
+      return group(document);
     return document;
   };

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

@@ -3,7 +3,7 @@ import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js';
 
 const { indent } = doc.builders;
 
-const createIndentIfNecessaryBuilder =
+export const createIndentIfNecessaryBuilder =
   (notIndentParentTypes) => (shouldIndentMatchers) => (path) => (document) => {
     let node = path.getNode();
     for (let i = 0; ; i += 1) {
@@ -15,14 +15,3 @@ const createIndentIfNecessaryBuilder =
       node = parentNode;
     }
   };
-
-export const createArithmeticIndentIfNecessaryBuilder =
-  createIndentIfNecessaryBuilder(['ReturnStatement']);
-
-export const createComparisonIndentIfNecessaryBuilder =
-  createIndentIfNecessaryBuilder([
-    'ReturnStatement',
-    'IfStatement',
-    'ForStatement',
-    'WhileStatement'
-  ]);

src/binary-operator-printers/printers/create-indent-if-necessary-builder.js

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