support for experimentalOperatorPosition

Author: Janther

src/binary-operator-printers/arithmetic.js

@@ -30,21 +30,25 @@ export const indentIfNecessaryBuilder = (path) => (document) => {
   }
 };
 
+export const rightOperand = (node, path, print, options) =>
+  options.experimentalOperatorPosition === 'end'
+    ? [' ', node.operator, line, path.call(print, 'right')]
+    : [line, node.operator, ' ', path.call(print, 'right')];
+
 export const arithmetic = {
   match: (op) => ['+', '-', '*', '/', '%'].includes(op),
-  print: (node, path, print) => {
+  print: (node, path, print, options) => {
     const groupIfNecessary = groupIfNecessaryBuilder(path);
     const indentIfNecessary = indentIfNecessaryBuilder(path);
 
-    const right = [node.operator, line, path.call(print, 'right')];
+    const right = rightOperand(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/comparison.js

@@ -1,4 +1,5 @@
 import { doc } from 'prettier';
+import { rightOperand } from './arithmetic.js';
 
 const { group, indent, line } = doc.builders;
 
@@ -18,18 +19,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 = rightOperand(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/exponentiation.js

@@ -1,13 +1,13 @@
 import { doc } from 'prettier';
-import { indentIfNecessaryBuilder } from './arithmetic.js';
+import { indentIfNecessaryBuilder, rightOperand } from './arithmetic.js';
 
 const { group, line } = doc.builders;
 
 export const exponentiation = {
   match: (op) => 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 = rightOperand(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 =

src/binary-operator-printers/logical.js

@@ -1,4 +1,5 @@
 import { doc } from 'prettier';
+import { rightOperand } from './arithmetic.js';
 
 const { group, line, indent } = doc.builders;
 
@@ -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 = rightOperand(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/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',