diff --git a/src/binary-operator-printers/addition.js b/src/binary-operator-printers/addition.js new file mode 100644 index 000000000..1711ff32f --- /dev/null +++ b/src/binary-operator-printers/addition.js @@ -0,0 +1,11 @@ +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: binaryOperationPrinter([shift, bit, inequality, equality, logical]) +}; diff --git a/src/binary-operator-printers/arithmetic.js b/src/binary-operator-printers/arithmetic.js deleted file mode 100644 index b7b4b1240..000000000 --- a/src/binary-operator-printers/arithmetic.js +++ /dev/null @@ -1,51 +0,0 @@ -import { doc } from 'prettier'; -import { comparison } from './comparison.js'; - -const { group, line, indent } = doc.builders; - -const groupIfNecessaryBuilder = (path) => (document) => { - const parentNode = path.getParentNode(); - if ( - parentNode.type === 'BinaryOperation' && - !comparison.match(parentNode.operator) - ) { - return document; - } - return group(document); -}; - -const indentIfNecessaryBuilder = (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) - ) { - return indent(document); - } - if (node === parentNode.right) return document; - node = parentNode; - } -}; - -export const arithmetic = { - match: (op) => ['+', '-', '*', '/', '%'].includes(op), - print: (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 shouldGroup = - node.left.type !== 'BinaryOperation' && - path.getParentNode().type !== 'BinaryOperation'; - return groupIfNecessary([ - path.call(print, 'left'), - ' ', - indentIfNecessary(shouldGroup ? group(right) : right) - ]); - } -}; diff --git a/src/binary-operator-printers/bit.js b/src/binary-operator-printers/bit.js index 761a182f8..c3d73d37c 100644 --- a/src/binary-operator-printers/bit.js +++ b/src/binary-operator-printers/bit.js @@ -1,6 +1,9 @@ -import { arithmetic } from './arithmetic.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: arithmetic.print + print: binaryOperationPrinter([inequality, equality, logical]) }; diff --git a/src/binary-operator-printers/comparison.js b/src/binary-operator-printers/comparison.js deleted file mode 100644 index 56e3a3acb..000000000 --- a/src/binary-operator-printers/comparison.js +++ /dev/null @@ -1,36 +0,0 @@ -import { doc } from 'prettier'; - -const { group, indent, line } = doc.builders; - -const indentIfNecessaryBuilder = (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 === 'IfStatement') return document; - if (parentNode.type === 'ForStatement') return document; - if (parentNode.type === 'WhileStatement') return document; - if (parentNode.type !== 'BinaryOperation') return indent(document); - if (node === parentNode.right) return document; - node = parentNode; - } -}; - -export const comparison = { - match: (op) => ['<', '>', '<=', '>=', '==', '!='].includes(op), - print: (node, path, print) => { - 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 shouldGroup = - node.left.type !== 'BinaryOperation' && - path.getParentNode().type !== 'BinaryOperation'; - return group([ - path.call(print, 'left'), - ' ', - indentIfNecessary(shouldGroup ? group(right) : right) - ]); - } -}; diff --git a/src/binary-operator-printers/equality.js b/src/binary-operator-printers/equality.js new file mode 100644 index 000000000..edb601231 --- /dev/null +++ b/src/binary-operator-printers/equality.js @@ -0,0 +1,7 @@ +import { binaryOperationPrinter } from './printers/binary-operation-printer.js'; +import { logical } from './logical.js'; + +export const equality = { + match: (op) => ['==', '!='].includes(op), + print: binaryOperationPrinter([logical]) +}; diff --git a/src/binary-operator-printers/exponentiation.js b/src/binary-operator-printers/exponentiation.js index 637f68075..2ea69068b 100644 --- a/src/binary-operator-printers/exponentiation.js +++ b/src/binary-operator-printers/exponentiation.js @@ -1,19 +1,28 @@ import { doc } from 'prettier'; +import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js'; +import { createIndentIfNecessaryBuilder } from './printers/create-indent-if-necessary-builder.js'; +import { multiplication } from './multiplication.js'; +import { addition } from './addition.js'; +import { shift } from './shift.js'; +import { bit } from './bit.js'; +import { inequality } from './inequality.js'; +import { equality } from './equality.js'; +import { logical } from './logical.js'; -const { group, indent, line } = doc.builders; +const { group } = doc.builders; 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: createBinaryOperationPrinter( + () => (document) => group(document), // always group + createIndentIfNecessaryBuilder([ + multiplication, + addition, + shift, + bit, + inequality, + equality, + logical + ]) + ) }; diff --git a/src/binary-operator-printers/index.js b/src/binary-operator-printers/index.js index e65a4f1e9..21f4b91d0 100644 --- a/src/binary-operator-printers/index.js +++ b/src/binary-operator-printers/index.js @@ -1,7 +1,9 @@ -export * from './arithmetic.js'; +export * from './addition.js'; export * from './assignment.js'; export * from './bit.js'; -export * from './comparison.js'; +export * from './equality.js'; export * from './exponentiation.js'; +export * from './inequality.js'; export * from './logical.js'; +export * from './multiplication.js'; export * from './shift.js'; diff --git a/src/binary-operator-printers/inequality.js b/src/binary-operator-printers/inequality.js new file mode 100644 index 000000000..dd1ad6778 --- /dev/null +++ b/src/binary-operator-printers/inequality.js @@ -0,0 +1,8 @@ +import { binaryOperationPrinter } from './printers/binary-operation-printer.js'; +import { logical } from './logical.js'; +import { equality } from './equality.js'; + +export const inequality = { + match: (op) => ['<', '>', '<=', '>='].includes(op), + print: binaryOperationPrinter([logical, equality]) +}; diff --git a/src/binary-operator-printers/logical.js b/src/binary-operator-printers/logical.js index e787cb7ce..bd327413c 100644 --- a/src/binary-operator-printers/logical.js +++ b/src/binary-operator-printers/logical.js @@ -1,24 +1,23 @@ import { doc } from 'prettier'; +import { createBinaryOperationPrinter } from './printers/create-binary-operation-printer.js'; +import { createGroupIfNecessaryBuilder } from './printers/create-group-if-necessary-builder.js'; +import { notIndentParentTypes } from './printers/create-indent-if-necessary-builder.js'; +import { shouldGroupOrIndent } from './utils/should-group-or-indent.js'; -const { group, line, indent } = doc.builders; - -const groupIfNecessaryBuilder = (path) => (document) => - path.getParentNode().type === 'BinaryOperation' ? document : group(document); +const { indent } = doc.builders; const indentIfNecessaryBuilder = (path, options) => (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 === 'IfStatement') return document; - if (parentNode.type === 'WhileStatement') return document; + if (notIndentParentTypes.includes(parentNode.type)) return document; if ( options.experimentalTernaries && parentNode.type === 'Conditional' && parentNode.condition === node ) return document; - if (parentNode.type !== 'BinaryOperation') return indent(document); + if (shouldGroupOrIndent(parentNode, [])) return indent(document); if (node === parentNode.right) return document; node = parentNode; } @@ -26,20 +25,8 @@ const indentIfNecessaryBuilder = (path, options) => (document) => { export const logical = { match: (op) => ['&&', '||'].includes(op), - print: (node, path, print, options) => { - const groupIfNecessary = groupIfNecessaryBuilder(path); - const indentIfNecessary = indentIfNecessaryBuilder(path, options); - - 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 groupIfNecessary([ - path.call(print, 'left'), - ' ', - indentIfNecessary(shouldGroup ? group(right) : right) - ]); - } + print: createBinaryOperationPrinter( + createGroupIfNecessaryBuilder([]), + indentIfNecessaryBuilder + ) }; diff --git a/src/binary-operator-printers/multiplication.js b/src/binary-operator-printers/multiplication.js new file mode 100644 index 000000000..dd39deed8 --- /dev/null +++ b/src/binary-operator-printers/multiplication.js @@ -0,0 +1,19 @@ +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'; +import { logical } from './logical.js'; + +export const multiplication = { + match: (op) => ['*', '/', '%'].includes(op), + print: binaryOperationPrinter([ + addition, + shift, + bit, + inequality, + equality, + logical + ]) +}; diff --git a/src/binary-operator-printers/printers/binary-operation-printer.js b/src/binary-operator-printers/printers/binary-operation-printer.js new file mode 100644 index 000000000..46dd8f76f --- /dev/null +++ b/src/binary-operator-printers/printers/binary-operation-printer.js @@ -0,0 +1,9 @@ +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 binaryOperationPrinter = (shouldGroupAndIndentMatchers) => + createBinaryOperationPrinter( + createGroupIfNecessaryBuilder(shouldGroupAndIndentMatchers), + createIndentIfNecessaryBuilder(shouldGroupAndIndentMatchers) + ); diff --git a/src/binary-operator-printers/printers/create-binary-operation-printer.js b/src/binary-operator-printers/printers/create-binary-operation-printer.js new file mode 100644 index 000000000..e7b182967 --- /dev/null +++ b/src/binary-operator-printers/printers/create-binary-operation-printer.js @@ -0,0 +1,31 @@ +import { doc } from 'prettier'; +import { assignment } from '../assignment.js'; + +const { group, line } = doc.builders; + +const rightOperandPrinter = (node, path, print, options) => { + const right = + options.experimentalOperatorPosition === 'end' + ? [' ', node.operator, line, path.call(print, 'right')] + : [line, node.operator, ' ', 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(); + return node.left.type !== 'BinaryOperation' && + (parent.type !== 'BinaryOperation' || assignment.match(parent.operator)) + ? group(right) + : right; +}; + +export const createBinaryOperationPrinter = + (groupIfNecessaryBuilder, indentIfNecessaryBuilder) => + (node, path, print, options) => { + const groupIfNecessary = groupIfNecessaryBuilder(path); + const indentIfNecessary = indentIfNecessaryBuilder(path, options); + + return groupIfNecessary([ + path.call(print, 'left'), + indentIfNecessary(rightOperandPrinter(node, path, print, options)) + ]); + }; diff --git a/src/binary-operator-printers/printers/create-group-if-necessary-builder.js b/src/binary-operator-printers/printers/create-group-if-necessary-builder.js new file mode 100644 index 000000000..136f3afd4 --- /dev/null +++ b/src/binary-operator-printers/printers/create-group-if-necessary-builder.js @@ -0,0 +1,12 @@ +import { doc } from 'prettier'; +import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js'; + +const { group } = doc.builders; + +export const createGroupIfNecessaryBuilder = + (shouldIndentMatchers) => (path) => (document) => { + const parentNode = path.getParentNode(); + if (shouldGroupOrIndent(parentNode, shouldIndentMatchers)) + return group(document); + return document; + }; diff --git a/src/binary-operator-printers/printers/create-indent-if-necessary-builder.js b/src/binary-operator-printers/printers/create-indent-if-necessary-builder.js new file mode 100644 index 000000000..3722ed260 --- /dev/null +++ b/src/binary-operator-printers/printers/create-indent-if-necessary-builder.js @@ -0,0 +1,24 @@ +import { doc } from 'prettier'; +import { shouldGroupOrIndent } from '../utils/should-group-or-indent.js'; + +const { indent } = doc.builders; + +export const notIndentParentTypes = [ + 'ReturnStatement', + 'IfStatement', + 'ForStatement', + 'WhileStatement' +]; + +export const createIndentIfNecessaryBuilder = + (shouldIndentMatchers) => (path) => (document) => { + let node = path.getNode(); + for (let i = 0; ; i += 1) { + const parentNode = path.getParentNode(i); + if (notIndentParentTypes.includes(parentNode.type)) return document; + if (shouldGroupOrIndent(parentNode, shouldIndentMatchers)) + return indent(document); + if (node === parentNode.right) return document; + node = parentNode; + } + }; diff --git a/src/binary-operator-printers/shift.js b/src/binary-operator-printers/shift.js index 026747cca..c58755127 100644 --- a/src/binary-operator-printers/shift.js +++ b/src/binary-operator-printers/shift.js @@ -1,6 +1,10 @@ -import { arithmetic } from './arithmetic.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: arithmetic.print + print: binaryOperationPrinter([bit, inequality, equality, logical]) }; diff --git a/src/binary-operator-printers/utils/should-group-or-indent.js b/src/binary-operator-printers/utils/should-group-or-indent.js new file mode 100644 index 000000000..9a5c4d6db --- /dev/null +++ b/src/binary-operator-printers/utils/should-group-or-indent.js @@ -0,0 +1,3 @@ +export const shouldGroupOrIndent = ({ type, operator }, matchers) => + type !== 'BinaryOperation' || + matchers.some((matcher) => matcher.match(operator)); diff --git a/src/options.js b/src/options.js index 34fa5a44d..f4bb65781 100644 --- a/src/options.js +++ b/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', diff --git a/src/parser.js b/src/parser.js index e2a119245..a305c9d3b 100644 --- a/src/parser.js +++ b/src/parser.js @@ -176,6 +176,10 @@ function parse(text, _parsers, options = _parsers) { '&' ]); break; + case '==': + case '!=': + ctx.left = tryHug(ctx.left, ['==', '!=']); + break; case '||': ctx.left = tryHug(ctx.left, ['&&']); ctx.right = tryHug(ctx.right, ['&&']); diff --git a/tests/format/BinaryOperationHierarchy/__snapshots__/jsfmt.spec.js.snap b/tests/format/BinaryOperationHierarchy/__snapshots__/jsfmt.spec.js.snap index 7c2655ccc..10a55638e 100644 --- a/tests/format/BinaryOperationHierarchy/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/BinaryOperationHierarchy/__snapshots__/jsfmt.spec.js.snap @@ -376,7 +376,7 @@ contract Group { function exp() public { resultUint256 = veryVeryVeryLongUint256A ** - veryVeryVeryLongUint256B ** veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B ** veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A ** veryVeryVeryLongUint256B * veryVeryVeryLongUint256C; @@ -442,12 +442,10 @@ contract Group { (veryVeryVeryLongUint256A * veryVeryVeryLongUint256B) % veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A * - veryVeryVeryLongUint256B + + veryVeryVeryLongUint256A * veryVeryVeryLongUint256B + veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A * - veryVeryVeryLongUint256B - + veryVeryVeryLongUint256A * veryVeryVeryLongUint256B - veryVeryVeryLongUint256C; resultUint256 = (veryVeryVeryLongUint256A * veryVeryVeryLongUint256B) << @@ -499,12 +497,10 @@ contract Group { (veryVeryVeryLongUint256A / veryVeryVeryLongUint256B) % veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A / - veryVeryVeryLongUint256B + + veryVeryVeryLongUint256A / veryVeryVeryLongUint256B + veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A / - veryVeryVeryLongUint256B - + veryVeryVeryLongUint256A / veryVeryVeryLongUint256B - veryVeryVeryLongUint256C; resultUint256 = (veryVeryVeryLongUint256A / veryVeryVeryLongUint256B) << @@ -561,24 +557,19 @@ contract Group { (veryVeryVeryLongUint256A % veryVeryVeryLongUint256B) - veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A % - veryVeryVeryLongUint256B << + veryVeryVeryLongUint256A % veryVeryVeryLongUint256B << veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A % - veryVeryVeryLongUint256B >> + veryVeryVeryLongUint256A % veryVeryVeryLongUint256B >> veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A % - veryVeryVeryLongUint256B & + veryVeryVeryLongUint256A % veryVeryVeryLongUint256B & veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A % - veryVeryVeryLongUint256B | + veryVeryVeryLongUint256A % veryVeryVeryLongUint256B | veryVeryVeryLongUint256C; resultUint256 = - veryVeryVeryLongUint256A % - veryVeryVeryLongUint256B ^ + veryVeryVeryLongUint256A % veryVeryVeryLongUint256B ^ veryVeryVeryLongUint256C; resultBoolean = veryVeryVeryLongUint256A % veryVeryVeryLongUint256B == @@ -606,12 +597,10 @@ contract Group { veryVeryVeryLongUint256B ** veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A + - veryVeryVeryLongUint256B * - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B * veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A + - veryVeryVeryLongUint256B / - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B / veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A + (veryVeryVeryLongUint256B % veryVeryVeryLongUint256C); @@ -664,12 +653,10 @@ contract Group { veryVeryVeryLongUint256B ** veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A - - veryVeryVeryLongUint256B * - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B * veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A - - veryVeryVeryLongUint256B / - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B / veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A - (veryVeryVeryLongUint256B % veryVeryVeryLongUint256C); @@ -728,8 +715,7 @@ contract Group { (veryVeryVeryLongUint256B / veryVeryVeryLongUint256C); resultUint256 = veryVeryVeryLongUint256A << - veryVeryVeryLongUint256B % - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B % veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A << (veryVeryVeryLongUint256B + veryVeryVeryLongUint256C); @@ -783,8 +769,7 @@ contract Group { (veryVeryVeryLongUint256B / veryVeryVeryLongUint256C); resultUint256 = veryVeryVeryLongUint256A >> - veryVeryVeryLongUint256B % - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B % veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A >> (veryVeryVeryLongUint256B + veryVeryVeryLongUint256C); @@ -838,8 +823,7 @@ contract Group { (veryVeryVeryLongUint256B / veryVeryVeryLongUint256C); resultUint256 = veryVeryVeryLongUint256A & - veryVeryVeryLongUint256B % - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B % veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A & (veryVeryVeryLongUint256B + veryVeryVeryLongUint256C); @@ -894,8 +878,7 @@ contract Group { (veryVeryVeryLongUint256B / veryVeryVeryLongUint256C); resultUint256 = veryVeryVeryLongUint256A | - veryVeryVeryLongUint256B % - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B % veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A | (veryVeryVeryLongUint256B + veryVeryVeryLongUint256C); @@ -950,8 +933,7 @@ contract Group { (veryVeryVeryLongUint256B / veryVeryVeryLongUint256C); resultUint256 = veryVeryVeryLongUint256A ^ - veryVeryVeryLongUint256B % - veryVeryVeryLongUint256C; + veryVeryVeryLongUint256B % veryVeryVeryLongUint256C; resultUint256 = veryVeryVeryLongUint256A ^ (veryVeryVeryLongUint256B + veryVeryVeryLongUint256C); @@ -1029,10 +1011,10 @@ contract Group { veryVeryVeryLongUint256A == veryVeryVeryLongUint256B ^ veryVeryVeryLongUint256C; resultBoolean = - veryVeryVeryLongUint256A == veryVeryVeryLongUint256B == + (veryVeryVeryLongUint256A == veryVeryVeryLongUint256B) == veryVeryVeryLongBooleanC; resultBoolean = - veryVeryVeryLongUint256A == veryVeryVeryLongUint256B != + (veryVeryVeryLongUint256A == veryVeryVeryLongUint256B) != veryVeryVeryLongBooleanC; resultBoolean = veryVeryVeryLongBooleanA == @@ -1083,10 +1065,10 @@ contract Group { veryVeryVeryLongUint256A != veryVeryVeryLongUint256B ^ veryVeryVeryLongUint256C; resultBoolean = - veryVeryVeryLongUint256A != veryVeryVeryLongUint256B == + (veryVeryVeryLongUint256A != veryVeryVeryLongUint256B) == veryVeryVeryLongBooleanC; resultBoolean = - veryVeryVeryLongUint256A != veryVeryVeryLongUint256B != + (veryVeryVeryLongUint256A != veryVeryVeryLongUint256B) != veryVeryVeryLongBooleanC; resultBoolean = veryVeryVeryLongBooleanA != @@ -1691,8 +1673,8 @@ contract Indent { function exp() public { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ** - veryVeryVeryExtremelyExtremelyLongUint256B ** - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256B ** + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ** veryVeryVeryExtremelyExtremelyLongUint256B * @@ -1778,11 +1760,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A * - veryVeryVeryExtremelyExtremelyLongUint256B + + veryVeryVeryExtremelyExtremelyLongUint256B + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A * - veryVeryVeryExtremelyExtremelyLongUint256B - + veryVeryVeryExtremelyExtremelyLongUint256B - veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = (veryVeryVeryExtremelyExtremelyLongUint256A * @@ -1849,11 +1831,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A / - veryVeryVeryExtremelyExtremelyLongUint256B + + veryVeryVeryExtremelyExtremelyLongUint256B + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A / - veryVeryVeryExtremelyExtremelyLongUint256B - + veryVeryVeryExtremelyExtremelyLongUint256B - veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = (veryVeryVeryExtremelyExtremelyLongUint256A / @@ -1928,23 +1910,23 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A % - veryVeryVeryExtremelyExtremelyLongUint256B << + veryVeryVeryExtremelyExtremelyLongUint256B << veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A % - veryVeryVeryExtremelyExtremelyLongUint256B >> + veryVeryVeryExtremelyExtremelyLongUint256B >> veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A % - veryVeryVeryExtremelyExtremelyLongUint256B & + veryVeryVeryExtremelyExtremelyLongUint256B & veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A % - veryVeryVeryExtremelyExtremelyLongUint256B | + veryVeryVeryExtremelyExtremelyLongUint256B | veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A % - veryVeryVeryExtremelyExtremelyLongUint256B ^ + veryVeryVeryExtremelyExtremelyLongUint256B ^ veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A % @@ -1980,11 +1962,11 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + veryVeryVeryExtremelyExtremelyLongUint256B * - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + veryVeryVeryExtremelyExtremelyLongUint256B / - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + (veryVeryVeryExtremelyExtremelyLongUint256B % @@ -2051,11 +2033,11 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - veryVeryVeryExtremelyExtremelyLongUint256B * - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - veryVeryVeryExtremelyExtremelyLongUint256B / - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - (veryVeryVeryExtremelyExtremelyLongUint256B % @@ -2130,7 +2112,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A << veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A << (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2201,7 +2183,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A >> veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A >> (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2272,7 +2254,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A & veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A & (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2343,7 +2325,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A | veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A | (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2414,7 +2396,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ^ veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ^ (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2515,29 +2497,29 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256B ^ veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = - veryVeryVeryExtremelyExtremelyLongUint256A == - veryVeryVeryExtremelyExtremelyLongUint256B == + (veryVeryVeryExtremelyExtremelyLongUint256A == + veryVeryVeryExtremelyExtremelyLongUint256B) == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = - veryVeryVeryExtremelyExtremelyLongUint256A == - veryVeryVeryExtremelyExtremelyLongUint256B != + (veryVeryVeryExtremelyExtremelyLongUint256A == + veryVeryVeryExtremelyExtremelyLongUint256B) != veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B < - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B <= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B > - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B >= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; } function notEqual() public { @@ -2586,29 +2568,29 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256B ^ veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = - veryVeryVeryExtremelyExtremelyLongUint256A != - veryVeryVeryExtremelyExtremelyLongUint256B == + (veryVeryVeryExtremelyExtremelyLongUint256A != + veryVeryVeryExtremelyExtremelyLongUint256B) == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = - veryVeryVeryExtremelyExtremelyLongUint256A != - veryVeryVeryExtremelyExtremelyLongUint256B != + (veryVeryVeryExtremelyExtremelyLongUint256A != + veryVeryVeryExtremelyExtremelyLongUint256B) != veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != veryVeryVeryExtremelyExtremelyLongUint256B < - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != veryVeryVeryExtremelyExtremelyLongUint256B <= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != veryVeryVeryExtremelyExtremelyLongUint256B > - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != veryVeryVeryExtremelyExtremelyLongUint256B >= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; } function lessThan() public { @@ -2658,11 +2640,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A < - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A < - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2713,11 +2695,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A <= - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A <= - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2768,11 +2750,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A > - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A > - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2823,11 +2805,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A >= - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A >= - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2843,11 +2825,11 @@ contract Indent { resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA || veryVeryVeryExtremelyExtremelyLongBooleanB == - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA || veryVeryVeryExtremelyExtremelyLongBooleanB != - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = (veryVeryVeryExtremelyExtremelyLongBooleanA && veryVeryVeryExtremelyExtremelyLongBooleanB) || @@ -2859,26 +2841,26 @@ contract Indent { resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA && veryVeryVeryExtremelyExtremelyLongBooleanB == - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA && veryVeryVeryExtremelyExtremelyLongBooleanB != - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == - veryVeryVeryExtremelyExtremelyLongBooleanB || + veryVeryVeryExtremelyExtremelyLongBooleanB || veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == - veryVeryVeryExtremelyExtremelyLongBooleanB && + veryVeryVeryExtremelyExtremelyLongBooleanB && veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != - veryVeryVeryExtremelyExtremelyLongBooleanB || + veryVeryVeryExtremelyExtremelyLongBooleanB || veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA != - veryVeryVeryExtremelyExtremelyLongBooleanB && + veryVeryVeryExtremelyExtremelyLongBooleanB && veryVeryVeryExtremelyExtremelyLongBooleanC; } } diff --git a/tests/format/BinaryOperators/__snapshots__/jsfmt.spec.js.snap b/tests/format/BinaryOperators/__snapshots__/jsfmt.spec.js.snap index f3c990af5..a44a77ee3 100644 --- a/tests/format/BinaryOperators/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/BinaryOperators/__snapshots__/jsfmt.spec.js.snap @@ -1,8 +1,9 @@ // Jest Snapshot v1, https://goo.gl/fbAQLP -exports[`BinaryOperators.sol - {"compiler":"0.5.8"} format 1`] = ` +exports[`BinaryOperators.sol - {"compiler":"0.5.8","experimentalOperatorPosition":"start"} format 1`] = ` ====================================options===================================== compiler: "0.5.8" +experimentalOperatorPosition: "start" parsers: ["solidity-parse"] printWidth: 80 | printWidth @@ -205,68 +206,67 @@ contract ArithmeticOperators { a % b; a ** b; (a % b) + c - (d * e) / f ** g; - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA - - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA * - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA / - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA % - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB - - (((c * d) / e) % f ** g); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + * veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + / veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + % veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB + - (((c * d) / e) % f ** g); a = - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; if ( - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB == - a() + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB + == a() ) {} if ( - a() == - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB + a() + == veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB ) {} for ( a = - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; - a <= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + a + <= veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; a += - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) + c; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) + - c * - veryVeryVeryVeryVeryLongFunctionCalledA( - veryVeryVeryVeryVeryLongVariableCalledB - ) - - d; + ) + + c + * veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + - d; a = veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) + - c; + ) + c; if ( veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB @@ -289,73 +289,72 @@ contract ArithmeticOperators { function someFunction() { a ** b; a ** c * d ** e; - a ** c * - d ** e * - a ** c * - d ** e * - a ** c * - d ** e * - a ** c * - d ** e * - a ** c * - d ** e; - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA * - veryVeryVeryVeryVeryLongVariableCalledB ** c; - c ** veryVeryVeryVeryVeryLongVariableCalledA * - veryVeryVeryVeryVeryLongVariableCalledB; + a ** c + * d ** e + * a ** c + * d ** e + * a ** c + * d ** e + * a ** c + * d ** e + * a ** c + * d ** e; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + * veryVeryVeryVeryVeryLongVariableCalledB ** c; + c ** veryVeryVeryVeryVeryLongVariableCalledA + * veryVeryVeryVeryVeryLongVariableCalledB; a = - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; a = - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB * - c; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB + * c; if ( - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB == - a() + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB + == a() ) {} if ( - a() == - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB + a() + == veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB ) {} for ( a = - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; - a <= - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; + a + <= veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; a += - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + ** veryVeryVeryVeryVeryLongVariableCalledB; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) ** c; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) ** - c * - veryVeryVeryVeryVeryLongFunctionCalledA( + ) + ** c + * veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) ** - d; + ) + ** d; a = veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) ** - c; + ) ** c; if ( veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB @@ -378,30 +377,30 @@ contract ShiftOperators { function someFunction() { a << b; a >> b; - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA >> - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + >> veryVeryVeryVeryVeryLongVariableCalledB; a = - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB; if ( - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB == - a() + veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB + == a() ) {} if ( - a() == - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB + a() + == veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA << - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + << veryVeryVeryVeryVeryLongVariableCalledB; } } @@ -411,32 +410,32 @@ contract BitOperators { a & b; a | b; a ^ b; - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA | - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA ^ - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + | veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + ^ veryVeryVeryVeryVeryLongVariableCalledB; a = - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB; if ( - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB == - a() + veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB + == a() ) {} if ( - a() == - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB + a() + == veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA & - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + & veryVeryVeryVeryVeryLongVariableCalledB; } } @@ -449,69 +448,68 @@ contract ComparisonOperators { a >= b; a == b; a != b; - veryVeryVeryVeryVeryLongVariableCalledA < - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA > - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA <= - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA >= - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA == - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA != - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + < veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + > veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + <= veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + >= veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + == veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + != veryVeryVeryVeryVeryLongVariableCalledB; a = - veryVeryVeryVeryVeryLongVariableCalledA < - veryVeryVeryVeryVeryLongVariableCalledB; - if ( - veryVeryVeryVeryVeryLongVariableCalledA > - veryVeryVeryVeryVeryLongFunctionB() - ) {} + veryVeryVeryVeryVeryLongVariableCalledA + < veryVeryVeryVeryVeryLongVariableCalledB; if ( - veryVeryVeryVeryVeryLongFunctionB() <= veryVeryVeryVeryVeryLongVariableCalledA + > veryVeryVeryVeryVeryLongFunctionB() ) {} - while ( - veryVeryVeryVeryVeryLongVariableCalledA != + if ( veryVeryVeryVeryVeryLongFunctionB() + <= veryVeryVeryVeryVeryLongVariableCalledA ) {} while ( - veryVeryVeryVeryVeryLongFunctionB() == veryVeryVeryVeryVeryLongVariableCalledA + != veryVeryVeryVeryVeryLongFunctionB() + ) {} + while ( + veryVeryVeryVeryVeryLongFunctionB() + == veryVeryVeryVeryVeryLongVariableCalledA ) {} for ( a = veryVeryVeryVeryVeryLongVariableCalledA; - veryVeryVeryVeryVeryLongVariableCalledB >= - veryVeryVeryVeryVeryLongVariableCalledA; - a += veryVeryVeryVeryVeryLongVariableCalledA || - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledB + >= veryVeryVeryVeryVeryLongVariableCalledA; + a += veryVeryVeryVeryVeryLongVariableCalledA + || veryVeryVeryVeryVeryLongVariableCalledB ? 1 : 2 ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA == - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + == veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA == - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + == veryVeryVeryVeryVeryLongVariableCalledB; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) == c; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) < - c || - veryVeryVeryVeryVeryLongFunctionCalledA( + ) + < c + || veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) > - d; + ) + > d; a = veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) == - c; + ) == c; if ( veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB @@ -544,38 +542,38 @@ contract AssignmentOperators { a /= veryVeryVeryVeryVeryLongVariableCalledA; a %= veryVeryVeryVeryVeryLongVariableCalledA; a = - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a |= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a ^= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a &= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a <<= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a >>= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a += - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a -= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a *= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a /= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); a %= - veryVeryVeryVeryVeryLongVariableCalledA + - veryVeryVeryVeryVeryLongFunctionCalledB(c); + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); } } @@ -585,87 +583,86 @@ contract LogicalOperators { a && b; a || b; a || (b && c) || (d && e); - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA || - veryVeryVeryVeryVeryLongVariableCalledB; - veryVeryVeryVeryVeryLongVariableCalledA || - (veryVeryVeryVeryVeryLongVariableCalledB && c) || - (d && e); + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + || veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + || (veryVeryVeryVeryVeryLongVariableCalledB && c) + || (d && e); a = - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB; if ( - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB == a() + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB == a() ) {} if ( - a() == veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB + a() == veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB ) {} if ( - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB ) {} if ( - (veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB) || c + (veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB) || c ) {} if ( - veryVeryVeryVeryVeryLongVariableCalledA || - (veryVeryVeryVeryVeryLongVariableCalledB && c) + veryVeryVeryVeryVeryLongVariableCalledA + || (veryVeryVeryVeryVeryLongVariableCalledB && c) ) {} while ( - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB == a() + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB == a() ) {} while ( - a() == veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB + a() == veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB ) {} while ( - veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB ) {} while ( - (veryVeryVeryVeryVeryLongVariableCalledA && - veryVeryVeryVeryVeryLongVariableCalledB) || c + (veryVeryVeryVeryVeryLongVariableCalledA + && veryVeryVeryVeryVeryLongVariableCalledB) || c ) {} while ( - veryVeryVeryVeryVeryLongVariableCalledA || - (veryVeryVeryVeryVeryLongVariableCalledB && c) + veryVeryVeryVeryVeryLongVariableCalledA + || (veryVeryVeryVeryVeryLongVariableCalledB && c) ) {} for ( a = veryVeryVeryVeryVeryLongVariableCalledA; a <= veryVeryVeryVeryVeryLongVariableCalledA; - a += veryVeryVeryVeryVeryLongVariableCalledA || - veryVeryVeryVeryVeryLongVariableCalledB + a += veryVeryVeryVeryVeryLongVariableCalledA + || veryVeryVeryVeryVeryLongVariableCalledB ? 1 : 2 ) {} a( - veryVeryVeryVeryVeryLongVariableCalledA || - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledA + || veryVeryVeryVeryVeryLongVariableCalledB ); return - veryVeryVeryVeryVeryLongVariableCalledA || - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + || veryVeryVeryVeryVeryLongVariableCalledB; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) || c; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) || - (c && - veryVeryVeryVeryVeryLongFunctionCalledA( + ) + || (c + && veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - )) || - d; + )) + || d; a = veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB - ) || - c; + ) || c; if ( veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB @@ -686,6 +683,965 @@ contract LogicalOperators { ================================================================================ `; +exports[`BinaryOperators.sol - {"compiler":"0.5.8"} format 1`] = ` +====================================options===================================== +compiler: "0.5.8" +parsers: ["solidity-parse"] +printWidth: 80 + | printWidth +=====================================input====================================== +contract ArithmeticOperators { + // ['+', '-', '*', '/', '%'] + function someFunction() { + a + b; + a - b; + a * b; + a / b; + a % b; + a ** b; + a % b + c - d * e / f ** g; + veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA * veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA / veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA % veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB - c * d / e % f ** g; + a = veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB; + if (veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + if (a() == veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB) {} + for (a = veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB; a <= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB; a += veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB) {} + a(veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c * veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) - d; + a = veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c; + if (veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c) {} + a(veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c); + return veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) + c; + } +} + + +contract ArithmeticOperators { + // ['**'] + function someFunction() { + a ** b; + a ** c * d ** e; + a ** c * d ** e * a ** c * d ** e * a ** c * d ** e * a ** c * d ** e * a ** c * d ** e; + veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA * veryVeryVeryVeryVeryLongVariableCalledB ** c; + c ** veryVeryVeryVeryVeryLongVariableCalledA * veryVeryVeryVeryVeryLongVariableCalledB; + a = veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; + a = veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB * c; + if (veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + if (a() == veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB) {} + for (a = veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; a <= veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; a += veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB) {} + a(veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c * veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** d; + a = veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c; + if (veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c) {} + a(veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c); + return veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) ** c; + } +} + + +contract ShiftOperators { + // ['<<', '>>'] + function someFunction() { + a << b; + a >> b; + veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA >> veryVeryVeryVeryVeryLongVariableCalledB; + a = veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB; + if (veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + if (a() == veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB) {} + a(veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA << veryVeryVeryVeryVeryLongVariableCalledB; + } +} + + +contract BitOperators { + // ['&', '|', '^'] + function someFunction() { + a & b; + a | b; + a ^ b; + veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA | veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA ^ veryVeryVeryVeryVeryLongVariableCalledB; + a = veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB; + if (veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + if (a() == veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB) {} + a(veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA & veryVeryVeryVeryVeryLongVariableCalledB; + } +} + + +contract ComparisonOperators { + // ['<', '>', '<=', '>=', '==', '!='] + function someFunction() { + a < b; + a > b; + a <= b; + a >= b; + a == b; + a != b; + veryVeryVeryVeryVeryLongVariableCalledA < veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA > veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA <= veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA >= veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA == veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA != veryVeryVeryVeryVeryLongVariableCalledB; + a = veryVeryVeryVeryVeryLongVariableCalledA < veryVeryVeryVeryVeryLongVariableCalledB; + if (veryVeryVeryVeryVeryLongVariableCalledA > veryVeryVeryVeryVeryLongFunctionB()) {} + if (veryVeryVeryVeryVeryLongFunctionB() <= veryVeryVeryVeryVeryLongVariableCalledA) {} + while (veryVeryVeryVeryVeryLongVariableCalledA != veryVeryVeryVeryVeryLongFunctionB()) {} + while (veryVeryVeryVeryVeryLongFunctionB() == veryVeryVeryVeryVeryLongVariableCalledA) {} + for (a = veryVeryVeryVeryVeryLongVariableCalledA; veryVeryVeryVeryVeryLongVariableCalledB >= veryVeryVeryVeryVeryLongVariableCalledA; a += veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB ? 1:2) {} + a(veryVeryVeryVeryVeryLongVariableCalledA == veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA == veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) == c; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) < c || veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) > d; + a = veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) == c; + if (veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) == c) {} + a(veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) == c); + return veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) == c; + } +} + + +contract AssignmentOperators { + // ['=', '|=', '^=', '&=', '<<=', '>>=', '+=', '-=', '*=', '/=', '%='] + function someFunction() { + a = veryVeryVeryVeryVeryLongVariableCalledA; + a |= veryVeryVeryVeryVeryLongVariableCalledA; + a ^= veryVeryVeryVeryVeryLongVariableCalledA; + a &= veryVeryVeryVeryVeryLongVariableCalledA; + a <<= veryVeryVeryVeryVeryLongVariableCalledA; + a >>= veryVeryVeryVeryVeryLongVariableCalledA; + a += veryVeryVeryVeryVeryLongVariableCalledA; + a -= veryVeryVeryVeryVeryLongVariableCalledA; + a *= veryVeryVeryVeryVeryLongVariableCalledA; + a /= veryVeryVeryVeryVeryLongVariableCalledA; + a %= veryVeryVeryVeryVeryLongVariableCalledA; + a = veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a |= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a ^= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a &= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a <<= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a >>= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a += veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a -= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a *= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a /= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a %= veryVeryVeryVeryVeryLongVariableCalledA + veryVeryVeryVeryVeryLongFunctionCalledB(c); + } +} + + +contract LogicalOperators { + // ['&&', '||'] + function someFunction() { + a && b; + a || b; + a || b && c || d && e; + veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB && c || d && e; + a = veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB; + if (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + if (a() == veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB) {} + if (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB) {} + if (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB || c) {} + if (veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB && c) {} + while (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB == a()) {} + while (a() == veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB) {} + while (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB) {} + while (veryVeryVeryVeryVeryLongVariableCalledA && veryVeryVeryVeryVeryLongVariableCalledB || c) {} + while (veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB && c) {} + for (a = veryVeryVeryVeryVeryLongVariableCalledA; a <= veryVeryVeryVeryVeryLongVariableCalledA; a += veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB ? 1:2) {} + a(veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB); + return veryVeryVeryVeryVeryLongVariableCalledA || veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c; + veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c && veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || d; + a = veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c; + if (veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c) {} + a(veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c); + return veryVeryVeryVeryVeryLongFunctionCalledA(veryVeryVeryVeryVeryLongVariableCalledB) || c; + } +} + +=====================================output===================================== +contract ArithmeticOperators { + // ['+', '-', '*', '/', '%'] + function someFunction() { + a + b; + a - b; + a * b; + a / b; + a % b; + a ** b; + (a % b) + c - (d * e) / f ** g; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA - + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA * + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA / + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA % + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB - + (((c * d) / e) % f ** g); + a = + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + if ( + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB == + a() + ) {} + if ( + a() == + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + for ( + a = + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + a <= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + a += + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + c; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + + c * + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) - + d; + a = + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + c; + if ( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + c + ) {} + a( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + c + ); + return + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) + c; + } +} + +contract ArithmeticOperators { + // ['**'] + function someFunction() { + a ** b; + a ** c * d ** e; + a ** c * + d ** e * + a ** c * + d ** e * + a ** c * + d ** e * + a ** c * + d ** e * + a ** c * + d ** e; + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA * + veryVeryVeryVeryVeryLongVariableCalledB ** c; + c ** veryVeryVeryVeryVeryLongVariableCalledA * + veryVeryVeryVeryVeryLongVariableCalledB; + a = + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + a = + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB * + c; + if ( + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB == + a() + ) {} + if ( + a() == + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + for ( + a = + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + a <= + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + a += + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA ** + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** c; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** + c * + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** + d; + a = + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** c; + if ( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** c + ) {} + a( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** c + ); + return + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) ** c; + } +} + +contract ShiftOperators { + // ['<<', '>>'] + function someFunction() { + a << b; + a >> b; + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA >> + veryVeryVeryVeryVeryLongVariableCalledB; + a = + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB; + if ( + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB == + a() + ) {} + if ( + a() == + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA << + veryVeryVeryVeryVeryLongVariableCalledB; + } +} + +contract BitOperators { + // ['&', '|', '^'] + function someFunction() { + a & b; + a | b; + a ^ b; + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA | + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA ^ + veryVeryVeryVeryVeryLongVariableCalledB; + a = + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB; + if ( + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB == + a() + ) {} + if ( + a() == + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA & + veryVeryVeryVeryVeryLongVariableCalledB; + } +} + +contract ComparisonOperators { + // ['<', '>', '<=', '>=', '==', '!='] + function someFunction() { + a < b; + a > b; + a <= b; + a >= b; + a == b; + a != b; + veryVeryVeryVeryVeryLongVariableCalledA < + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA > + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA <= + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA >= + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA == + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA != + veryVeryVeryVeryVeryLongVariableCalledB; + a = + veryVeryVeryVeryVeryLongVariableCalledA < + veryVeryVeryVeryVeryLongVariableCalledB; + if ( + veryVeryVeryVeryVeryLongVariableCalledA > + veryVeryVeryVeryVeryLongFunctionB() + ) {} + if ( + veryVeryVeryVeryVeryLongFunctionB() <= + veryVeryVeryVeryVeryLongVariableCalledA + ) {} + while ( + veryVeryVeryVeryVeryLongVariableCalledA != + veryVeryVeryVeryVeryLongFunctionB() + ) {} + while ( + veryVeryVeryVeryVeryLongFunctionB() == + veryVeryVeryVeryVeryLongVariableCalledA + ) {} + for ( + a = veryVeryVeryVeryVeryLongVariableCalledA; + veryVeryVeryVeryVeryLongVariableCalledB >= + veryVeryVeryVeryVeryLongVariableCalledA; + a += veryVeryVeryVeryVeryLongVariableCalledA || + veryVeryVeryVeryVeryLongVariableCalledB + ? 1 + : 2 + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA == + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA == + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) == c; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) < + c || + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) > + d; + a = + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) == c; + if ( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) == c + ) {} + a( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) == c + ); + return + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) == c; + } +} + +contract AssignmentOperators { + // ['=', '|=', '^=', '&=', '<<=', '>>=', '+=', '-=', '*=', '/=', '%='] + function someFunction() { + a = veryVeryVeryVeryVeryLongVariableCalledA; + a |= veryVeryVeryVeryVeryLongVariableCalledA; + a ^= veryVeryVeryVeryVeryLongVariableCalledA; + a &= veryVeryVeryVeryVeryLongVariableCalledA; + a <<= veryVeryVeryVeryVeryLongVariableCalledA; + a >>= veryVeryVeryVeryVeryLongVariableCalledA; + a += veryVeryVeryVeryVeryLongVariableCalledA; + a -= veryVeryVeryVeryVeryLongVariableCalledA; + a *= veryVeryVeryVeryVeryLongVariableCalledA; + a /= veryVeryVeryVeryVeryLongVariableCalledA; + a %= veryVeryVeryVeryVeryLongVariableCalledA; + a = + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a |= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a ^= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a &= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a <<= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a >>= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a += + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a -= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a *= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a /= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + a %= + veryVeryVeryVeryVeryLongVariableCalledA + + veryVeryVeryVeryVeryLongFunctionCalledB(c); + } +} + +contract LogicalOperators { + // ['&&', '||'] + function someFunction() { + a && b; + a || b; + a || (b && c) || (d && e); + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA || + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledA || + (veryVeryVeryVeryVeryLongVariableCalledB && c) || + (d && e); + a = + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB; + if ( + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB == a() + ) {} + if ( + a() == veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + if ( + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + if ( + (veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB) || c + ) {} + if ( + veryVeryVeryVeryVeryLongVariableCalledA || + (veryVeryVeryVeryVeryLongVariableCalledB && c) + ) {} + while ( + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB == a() + ) {} + while ( + a() == veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + while ( + veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB + ) {} + while ( + (veryVeryVeryVeryVeryLongVariableCalledA && + veryVeryVeryVeryVeryLongVariableCalledB) || c + ) {} + while ( + veryVeryVeryVeryVeryLongVariableCalledA || + (veryVeryVeryVeryVeryLongVariableCalledB && c) + ) {} + for ( + a = veryVeryVeryVeryVeryLongVariableCalledA; + a <= veryVeryVeryVeryVeryLongVariableCalledA; + a += veryVeryVeryVeryVeryLongVariableCalledA || + veryVeryVeryVeryVeryLongVariableCalledB + ? 1 + : 2 + ) {} + a( + veryVeryVeryVeryVeryLongVariableCalledA || + veryVeryVeryVeryVeryLongVariableCalledB + ); + return + veryVeryVeryVeryVeryLongVariableCalledA || + veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || c; + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || + (c && + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + )) || + d; + a = + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || c; + if ( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || c + ) {} + a( + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || c + ); + return + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) || c; + } +} + +================================================================================ +`; + +exports[`Parentheses.sol - {"compiler":"0.5.8","experimentalOperatorPosition":"start"} format 1`] = ` +====================================options===================================== +compiler: "0.5.8" +experimentalOperatorPosition: "start" +parsers: ["solidity-parse"] +printWidth: 80 + | printWidth +=====================================input====================================== +pragma solidity 0.5.8; + + +contract Parentheses { + function() { + a + b + c; + a + b - c; + a + b * c; + a + b / c; + a + b % c; + a + b ** c; + a + b << c; + a + b >> c; + a + b & c; + a + b | c; + a + b ^ c; + a - b + c; + a - b - c; + a - b * c; + a - b / c; + a - b % c; + a - b ** c; + a - b << c; + a - b >> c; + a - b & c; + a - b | c; + a - b ^ c; + a * b + c; + a * b - c; + a * b * c; + a * b / c; + a * b % c; + a * b ** c; + a * b << c; + a * b >> c; + a * b & c; + a * b | c; + a * b ^ c; + a / b + c; + a / b - c; + a / b * c; + a / b / c; + a / b % c; + a / b ** c; + a / b << c; + a / b >> c; + a / b & c; + a / b | c; + a / b ^ c; + a % b + c; + a % b - c; + a % b * c; + a % b / c; + a % b % c; + a % b ** c; + a % b << c; + a % b >> c; + a % b & c; + a % b | c; + a % b ^ c; + a ** b + c; + a ** b - c; + a ** b * c; + a ** b / c; + a ** b % c; + a ** b ** c; + a ** b << c; + a ** b >> c; + a ** b & c; + a ** b | c; + a ** b ^ c; + a << b + c; + a << b - c; + a << b * c; + a << b / c; + a << b % c; + a << b ** c; + a << b << c; + a << b >> c; + a << b & c; + a << b | c; + a << b ^ c; + a >> b + c; + a >> b - c; + a >> b * c; + a >> b / c; + a >> b % c; + a >> b ** c; + a >> b << c; + a >> b >> c; + a >> b & c; + a >> b | c; + a >> b ^ c; + a & b + c; + a & b - c; + a & b * c; + a & b / c; + a & b % c; + a & b ** c; + a & b << c; + a & b >> c; + a & b & c; + a & b | c; + a & b ^ c; + a | b + c; + a | b - c; + a | b * c; + a | b / c; + a | b % c; + a | b ** c; + a | b << c; + a | b >> c; + a | b & c; + a | b | c; + a | b ^ c; + a ^ b + c; + a ^ b - c; + a ^ b * c; + a ^ b / c; + a ^ b % c; + a ^ b ** c; + a ^ b << c; + a ^ b >> c; + a ^ b & c; + a ^ b | c; + a ^ b ^ c; + a || b || c; + a || b && c; + a && b || c; + a && b && c; + } +} + +=====================================output===================================== +pragma solidity 0.5.8; + +contract Parentheses { + function() { + a + b + c; + a + b - c; + a + b * c; + a + b / c; + a + (b % c); + a + b ** c; + (a + b) << c; + (a + b) >> c; + (a + b) & c; + (a + b) | c; + (a + b) ^ c; + a - b + c; + a - b - c; + a - b * c; + a - b / c; + a - (b % c); + a - b ** c; + (a - b) << c; + (a - b) >> c; + (a - b) & c; + (a - b) | c; + (a - b) ^ c; + a * b + c; + a * b - c; + a * b * c; + (a * b) / c; + (a * b) % c; + a * b ** c; + (a * b) << c; + (a * b) >> c; + (a * b) & c; + (a * b) | c; + (a * b) ^ c; + a / b + c; + a / b - c; + (a / b) * c; + a / b / c; + (a / b) % c; + a / b ** c; + (a / b) << c; + (a / b) >> c; + (a / b) & c; + (a / b) | c; + (a / b) ^ c; + (a % b) + c; + (a % b) - c; + (a % b) * c; + (a % b) / c; + (a % b) % c; + a % b ** c; + a % b << c; + a % b >> c; + a % b & c; + a % b | c; + a % b ^ c; + a ** b + c; + a ** b - c; + a ** b * c; + a ** b / c; + a ** b % c; + (a ** b) ** c; + (a ** b) << c; + (a ** b) >> c; + (a ** b) & c; + (a ** b) | c; + (a ** b) ^ c; + a << (b + c); + a << (b - c); + a << (b * c); + a << (b / c); + a << b % c; + a << (b ** c); + (a << b) << c; + (a << b) >> c; + (a << b) & c; + (a << b) | c; + (a << b) ^ c; + a >> (b + c); + a >> (b - c); + a >> (b * c); + a >> (b / c); + a >> b % c; + a >> (b ** c); + (a >> b) << c; + (a >> b) >> c; + (a >> b) & c; + (a >> b) | c; + (a >> b) ^ c; + a & (b + c); + a & (b - c); + a & (b * c); + a & (b / c); + a & b % c; + a & (b ** c); + a & (b << c); + a & (b >> c); + a & b & c; + (a & b) | c; + (a & b) ^ c; + a | (b + c); + a | (b - c); + a | (b * c); + a | (b / c); + a | b % c; + a | (b ** c); + a | (b << c); + a | (b >> c); + a | (b & c); + a | b | c; + a | (b ^ c); + a ^ (b + c); + a ^ (b - c); + a ^ (b * c); + a ^ (b / c); + a ^ b % c; + a ^ (b ** c); + a ^ (b << c); + a ^ (b >> c); + a ^ (b & c); + (a ^ b) | c; + a ^ b ^ c; + a || b || c; + a || (b && c); + (a && b) || c; + a && b && c; + } +} + +================================================================================ +`; + exports[`Parentheses.sol - {"compiler":"0.5.8"} format 1`] = ` ====================================options===================================== compiler: "0.5.8" diff --git a/tests/format/BinaryOperators/jsfmt.spec.js b/tests/format/BinaryOperators/jsfmt.spec.js index 946858815..ec876ca43 100644 --- a/tests/format/BinaryOperators/jsfmt.spec.js +++ b/tests/format/BinaryOperators/jsfmt.spec.js @@ -1 +1,5 @@ run_spec(import.meta, ['solidity-parse'], { compiler: '0.5.8' }); +run_spec(import.meta, ['solidity-parse'], { + compiler: '0.5.8', + experimentalOperatorPosition: 'start' +}); diff --git a/tests/format/ContractDefinitions/__snapshots__/jsfmt.spec.js.snap b/tests/format/ContractDefinitions/__snapshots__/jsfmt.spec.js.snap index e67a4276d..93c446beb 100644 --- a/tests/format/ContractDefinitions/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/ContractDefinitions/__snapshots__/jsfmt.spec.js.snap @@ -72,10 +72,8 @@ contract StorageLayoutSpecifier1 layout at contract StorageLayoutSpecifier2 layout at veryVeryLongFunction( - 12345678901234567890 * - 12345678901234567890 - - 12345678901234567890 / - 12345678901234567890 + + 12345678901234567890 * 12345678901234567890 - + 12345678901234567890 / 12345678901234567890 + 12345678901234567890 - 12345678901234567890 ) @@ -97,10 +95,8 @@ contract StorageLayoutSpecifier6 is Contract1, Contract2, Contract3, Contract4, Contract5 layout at veryVeryLongFunction( - 12345678901234567890 * - 12345678901234567890 - - 12345678901234567890 / - 12345678901234567890 + + 12345678901234567890 * 12345678901234567890 - + 12345678901234567890 / 12345678901234567890 + 12345678901234567890 - 12345678901234567890 ) @@ -142,10 +138,8 @@ contract StorageLayoutSpecifier9 Contract7 layout at veryVeryLongFunction( - 12345678901234567890 * - 12345678901234567890 - - 12345678901234567890 / - 12345678901234567890 + + 12345678901234567890 * 12345678901234567890 - + 12345678901234567890 / 12345678901234567890 + 12345678901234567890 - 12345678901234567890 ) @@ -168,10 +162,8 @@ contract InheritanceSpecifier4 is SomeOtherContract(1234, false) layout at veryVeryLongFunction( - 12345678901234567890 * - 12345678901234567890 - - 12345678901234567890 / - 12345678901234567890 + + 12345678901234567890 * 12345678901234567890 - + 12345678901234567890 / 12345678901234567890 + 12345678901234567890 - 12345678901234567890 ) @@ -215,10 +207,8 @@ contract LongInheritanceSpecifier4 ) layout at veryVeryLongFunction( - 12345678901234567890 * - 12345678901234567890 - - 12345678901234567890 / - 12345678901234567890 + + 12345678901234567890 * 12345678901234567890 - + 12345678901234567890 / 12345678901234567890 + 12345678901234567890 - 12345678901234567890 ) diff --git a/tests/format/ExperimentalTernaries/__snapshots__/jsfmt.spec.js.snap b/tests/format/ExperimentalTernaries/__snapshots__/jsfmt.spec.js.snap index a290e72ad..e1d06fedd 100644 --- a/tests/format/ExperimentalTernaries/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/ExperimentalTernaries/__snapshots__/jsfmt.spec.js.snap @@ -409,7 +409,7 @@ contract Conditional { ( bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl().anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl().anodyneCondosMalateOverateRetinol() ) ? "foo" : "bar"; @@ -420,7 +420,7 @@ contract Conditional { ( bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl().anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl().anodyneCondosMalateOverateRetinol() ) ? "foo" : anotherCondition ? "bar" @@ -920,8 +920,8 @@ contract Conditional { bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol() ) ? "foo" : "bar"; @@ -933,8 +933,8 @@ contract Conditional { bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol() ) ? "foo" : anotherCondition ? "bar" @@ -1433,8 +1433,8 @@ contract Conditional { bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol() ) ? "foo" : "bar"; @@ -1446,8 +1446,8 @@ contract Conditional { bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol() + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol() ) ? "foo" : anotherCondition ? "bar" @@ -1945,8 +1945,8 @@ contract Conditional { string storage longConditional = (bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol()) + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol()) ? "foo" : "bar"; @@ -1956,8 +1956,8 @@ contract Conditional { storage longConditionalChained = (bifornCringerMoshedPerplexSawder == 2 / askTrovenaBeenaDependsRowans && glimseGlyphsHazardNoopsTieTie >= - averredBathersBoxroomBuggyNurl() - .anodyneCondosMalateOverateRetinol()) + averredBathersBoxroomBuggyNurl() + .anodyneCondosMalateOverateRetinol()) ? "foo" : anotherCondition ? "bar" diff --git a/tests/format/Parentheses/LogicNoParentheses.sol b/tests/format/Parentheses/LogicNoParentheses.sol index 2345f549f..c2414f4bf 100644 --- a/tests/format/Parentheses/LogicNoParentheses.sol +++ b/tests/format/Parentheses/LogicNoParentheses.sol @@ -17,4 +17,20 @@ contract LogicNoParentheses { function andAnd(bool a, bool b, bool c) public pure returns (bool) { return a && b && c; } + + function equalEqual(bool a, bool b, bool c) public pure returns (bool) { + return a == b == c; + } + + function equalNotEqual(bool a, bool b, bool c) public pure returns (bool) { + return a == b != c; + } + + function notEqualEqual(bool a, bool b, bool c) public pure returns (bool) { + return a != b == c; + } + + function notEqualNotEqual(bool a, bool b, bool c) public pure returns (bool) { + return a != b != c; + } } diff --git a/tests/format/Parentheses/__snapshots__/jsfmt.spec.js.snap b/tests/format/Parentheses/__snapshots__/jsfmt.spec.js.snap index e51bd2d48..408639764 100644 --- a/tests/format/Parentheses/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/Parentheses/__snapshots__/jsfmt.spec.js.snap @@ -1208,6 +1208,22 @@ contract LogicNoParentheses { function andAnd(bool a, bool b, bool c) public pure returns (bool) { return a && b && c; } + + function equalEqual(bool a, bool b, bool c) public pure returns (bool) { + return a == b == c; + } + + function equalNotEqual(bool a, bool b, bool c) public pure returns (bool) { + return a == b != c; + } + + function notEqualEqual(bool a, bool b, bool c) public pure returns (bool) { + return a != b == c; + } + + function notEqualNotEqual(bool a, bool b, bool c) public pure returns (bool) { + return a != b != c; + } } =====================================output===================================== @@ -1230,6 +1246,26 @@ contract LogicNoParentheses { function andAnd(bool a, bool b, bool c) public pure returns (bool) { return a && b && c; } + + function equalEqual(bool a, bool b, bool c) public pure returns (bool) { + return (a == b) == c; + } + + function equalNotEqual(bool a, bool b, bool c) public pure returns (bool) { + return (a == b) != c; + } + + function notEqualEqual(bool a, bool b, bool c) public pure returns (bool) { + return (a != b) == c; + } + + function notEqualNotEqual( + bool a, + bool b, + bool c + ) public pure returns (bool) { + return (a != b) != c; + } } ================================================================================ diff --git a/tests/format/strings/__snapshots__/jsfmt.spec.js.snap b/tests/format/strings/__snapshots__/jsfmt.spec.js.snap index 2ec8073d9..b087b7a43 100644 --- a/tests/format/strings/__snapshots__/jsfmt.spec.js.snap +++ b/tests/format/strings/__snapshots__/jsfmt.spec.js.snap @@ -1475,8 +1475,7 @@ library strings { ptr, needle._len, needle._ptr - ) + - needle._len; + ) + needle._len; } } diff --git a/tests/unit/binary-operator-printers/__snapshots__/index.test.js.snap b/tests/unit/binary-operator-printers/__snapshots__/index.test.js.snap index 8f92fd9c2..e7286bd0a 100644 --- a/tests/unit/binary-operator-printers/__snapshots__/index.test.js.snap +++ b/tests/unit/binary-operator-printers/__snapshots__/index.test.js.snap @@ -2,12 +2,14 @@ exports[`binary operators printers to match snapshot 1`] = ` [ - "arithmetic", + "addition", "assignment", "bit", - "comparison", + "equality", "exponentiation", + "inequality", "logical", + "multiplication", "shift", ] `;