support for experimentalOperatorPosition

Author: Janther

src/binary-operator-printers/comparison.js

@@ -1,7 +1,8 @@
 import { doc } from 'prettier';
+import { rightOperandPrinter } from './printers/right-operand-printer.js';
 import { logical } from './logical.js';
 
-const { group, indent, line } = doc.builders;
+const { group, indent } = doc.builders;
 
 const indentIfNecessaryBuilder = (path) => (document) => {
   let node = path.getNode();
@@ -20,18 +21,17 @@ const indentIfNecessaryBuilder = (path) => (document) => {
 
 export const comparison = {
   match: (op) => ['<', '>', '<=', '>=', '==', '!='].includes(op),
-  print: (node, path, print) => {
+  print: (node, path, print, options) => {
     const indentIfNecessary = indentIfNecessaryBuilder(path);
 
-    const right = [node.operator, line, path.call(print, 'right')];
+    const right = rightOperandPrinter(node, path, print, options);
     // 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'),
-      ' ',
       indentIfNecessary(shouldGroup ? group(right) : right)
     ]);
   }

src/binary-operator-printers/logical.js

@@ -1,6 +1,7 @@
 import { doc } from 'prettier';
+import { rightOperandPrinter } from './printers/right-operand-printer.js';
 
-const { group, line, indent } = doc.builders;
+const { group, indent } = doc.builders;
 
 const groupIfNecessaryBuilder = (path) => (document) =>
   path.getParentNode().type === 'BinaryOperation' ? document : group(document);
@@ -30,15 +31,14 @@ export const logical = {
     const groupIfNecessary = groupIfNecessaryBuilder(path);
     const indentIfNecessary = indentIfNecessaryBuilder(path, options);
 
-    const right = [node.operator, line, path.call(print, 'right')];
+    const right = rightOperandPrinter(node, path, print, options);
     // 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 groupIfNecessary([
       path.call(print, 'left'),
-      ' ',
       indentIfNecessary(shouldGroup ? group(right) : right)
     ]);
   }

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

@@ -1,8 +1,9 @@
 import { doc } from 'prettier';
 import { assignment } from '../assignment.js';
 import { comparison } from '../comparison.js';
+import { rightOperandPrinter } from './right-operand-printer.js';
 
-const { group, indent, line } = doc.builders;
+const { group, indent } = doc.builders;
 
 const shouldGroupOrIndent = (node, matchers) =>
   matchers.some((matcher) => matcher.match(node.operator));
@@ -41,11 +42,11 @@ export const createIndentIfNecessaryBuilder =
 
 export const createBinaryOperationPrinter =
   (groupIfNecessaryBuilder, indentIfNecessaryBuilder) =>
-  (node, path, print) => {
+  (node, path, print, options) => {
     const groupIfNecessary = groupIfNecessaryBuilder(path);
     const indentIfNecessary = indentIfNecessaryBuilder(path);
 
-    const right = [' ', node.operator, line, path.call(print, 'right')];
+    const right = rightOperandPrinter(node, path, print, options);
     // If it's a single binary operation, avoid having a small right
     // operand like - 1 on its own line
     const parent = path.getParentNode();

src/binary-operator-printers/printers/right-operand-printer.js

@@ -0,0 +1,8 @@
+import { doc } from 'prettier';
+
+const { line } = doc.builders;
+
+export const rightOperandPrinter = (node, path, print, options) =>
+  options.experimentalOperatorPosition === 'end'
+    ? [' ', node.operator, line, path.call(print, 'right')]
+    : [line, node.operator, ' ', path.call(print, 'right')];

src/options.js

@@ -50,6 +50,22 @@ const options = {
     oppositeDescription:
       'Default behavior of ternaries; keep question marks on the same line as the consequent.'
   },
+  experimentalOperatorPosition: {
+    category: CATEGORY_JAVASCRIPT,
+    type: 'choice',
+    default: 'end',
+    description: 'Where to print operators when binary expressions wrap lines.',
+    choices: [
+      {
+        value: 'start',
+        description: 'Print operators at the start of new lines.'
+      },
+      {
+        value: 'end',
+        description: 'Print operators at the end of previous lines.'
+      }
+    ]
+  },
   compiler: {
     category: CATEGORY_SOLIDITY,
     type: 'string',