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..cc6d309c3 --- /dev/null +++ b/src/binary-operator-printers/printers/create-binary-operation-printer.js @@ -0,0 +1,28 @@ +import { doc } from 'prettier'; +import { assignment } from '../assignment.js'; + +const { group, line } = doc.builders; + +const rightOperandPrinter = (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 parent = path.getParentNode(); + return node.left.type !== 'BinaryOperation' && + parent.type !== 'BinaryOperation' + ? 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)) + ]); + }; 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/slang-nodes/AdditiveExpression.ts b/src/slang-nodes/AdditiveExpression.ts index 2dbc905d1..a85f31b73 100644 --- a/src/slang-nodes/AdditiveExpression.ts +++ b/src/slang-nodes/AdditiveExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -11,6 +12,19 @@ import type { PrintFunction, SlangNode } from '../types.d.ts'; const tryToHug = createHugFunction(['%']); +const printAdditiveExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.ShiftExpression, + NonterminalKind.BitwiseAndExpression, + NonterminalKind.BitwiseOrExpression, + NonterminalKind.BitwiseXorExpression, + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class AdditiveExpression implements SlangNode { readonly kind = NonterminalKind.AdditiveExpression; @@ -45,6 +59,6 @@ export class AdditiveExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printAdditiveExpression(this, path, print, options); } } diff --git a/src/slang-nodes/BitwiseAndExpression.ts b/src/slang-nodes/BitwiseAndExpression.ts index ae19edc2f..e936c83a8 100644 --- a/src/slang-nodes/BitwiseAndExpression.ts +++ b/src/slang-nodes/BitwiseAndExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -11,6 +12,15 @@ import type { PrintFunction, SlangNode } from '../types.d.ts'; const tryToHug = createHugFunction(['+', '-', '*', '/', '**', '<<', '>>']); +const printBitwiseAndExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class BitwiseAndExpression implements SlangNode { readonly kind = NonterminalKind.BitwiseAndExpression; @@ -45,6 +55,6 @@ export class BitwiseAndExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printBitwiseAndExpression(this, path, print, options); } } diff --git a/src/slang-nodes/BitwiseOrExpression.ts b/src/slang-nodes/BitwiseOrExpression.ts index cfe3ba41f..614e71b4b 100644 --- a/src/slang-nodes/BitwiseOrExpression.ts +++ b/src/slang-nodes/BitwiseOrExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -21,6 +22,15 @@ const tryToHug = createHugFunction([ '^' ]); +const printBitwiseOrExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class BitwiseOrExpression implements SlangNode { readonly kind = NonterminalKind.BitwiseOrExpression; @@ -55,6 +65,6 @@ export class BitwiseOrExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printBitwiseOrExpression(this, path, print, options); } } diff --git a/src/slang-nodes/BitwiseXorExpression.ts b/src/slang-nodes/BitwiseXorExpression.ts index c8d6a70e7..f341e8155 100644 --- a/src/slang-nodes/BitwiseXorExpression.ts +++ b/src/slang-nodes/BitwiseXorExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -11,6 +12,15 @@ import type { PrintFunction, SlangNode } from '../types.d.ts'; const tryToHug = createHugFunction(['+', '-', '*', '/', '**', '<<', '>>', '&']); +const printBitwiseXorExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class BitwiseXorExpression implements SlangNode { readonly kind = NonterminalKind.BitwiseXorExpression; @@ -45,6 +55,6 @@ export class BitwiseXorExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printBitwiseXorExpression(this, path, print, options); } } diff --git a/src/slang-nodes/EqualityExpression.ts b/src/slang-nodes/EqualityExpression.ts index 3faed90bf..db5b521e8 100644 --- a/src/slang-nodes/EqualityExpression.ts +++ b/src/slang-nodes/EqualityExpression.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printComparisonOperation } from '../slang-printers/print-comparison-operation.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; +import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -8,6 +9,13 @@ import type { AstPath, Doc, ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; import type { PrintFunction, SlangNode } from '../types.d.ts'; +const printEqualityExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class EqualityExpression implements SlangNode { readonly kind = NonterminalKind.EqualityExpression; @@ -39,6 +47,6 @@ export class EqualityExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printComparisonOperation(this, path, print, options); + return printEqualityExpression(this, path, print, options); } } diff --git a/src/slang-nodes/ExponentiationExpression.ts b/src/slang-nodes/ExponentiationExpression.ts index 8f596a7e1..0a0e7a979 100644 --- a/src/slang-nodes/ExponentiationExpression.ts +++ b/src/slang-nodes/ExponentiationExpression.ts @@ -1,7 +1,9 @@ import { doc } from 'prettier'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { createBinaryOperationPrinter } from '../slang-printers/create-binary-operation-printer.js'; +import { binaryIndentRulesBuilder } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -10,17 +12,28 @@ import type { AstPath, Doc, ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; import type { PrintFunction, SlangNode } from '../types.d.ts'; -const { group, indent } = doc.builders; +const { group } = doc.builders; const tryToHug = createHugFunction(['**']); +const shouldIndent = createKindCheckFunction([ + NonterminalKind.MultiplicativeExpression, + NonterminalKind.AdditiveExpression, + NonterminalKind.ShiftExpression, + NonterminalKind.BitwiseAndExpression, + NonterminalKind.BitwiseOrExpression, + NonterminalKind.BitwiseXorExpression, + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression +]); + const printExponentiationExpression = createBinaryOperationPrinter( () => (document: Doc): Doc => group(document), // always group - () => - (document: Doc): Doc => - indent(document) // always indent + binaryIndentRulesBuilder(shouldIndent) // indent as a binary operation with some exceptions ); export class ExponentiationExpression implements SlangNode { diff --git a/src/slang-nodes/InequalityExpression.ts b/src/slang-nodes/InequalityExpression.ts index 3a03ec59c..c80930265 100644 --- a/src/slang-nodes/InequalityExpression.ts +++ b/src/slang-nodes/InequalityExpression.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printComparisonOperation } from '../slang-printers/print-comparison-operation.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; +import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -8,6 +9,14 @@ import type { AstPath, Doc, ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; import type { PrintFunction, SlangNode } from '../types.d.ts'; +const printComparisonExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class InequalityExpression implements SlangNode { readonly kind = NonterminalKind.InequalityExpression; @@ -39,6 +48,6 @@ export class InequalityExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printComparisonOperation(this, path, print, options); + return printComparisonExpression(this, path, print, options); } } diff --git a/src/slang-nodes/MultiplicativeExpression.ts b/src/slang-nodes/MultiplicativeExpression.ts index cb10aa660..f0e480a54 100644 --- a/src/slang-nodes/MultiplicativeExpression.ts +++ b/src/slang-nodes/MultiplicativeExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -13,6 +14,20 @@ const multiplicationTryToHug = createHugFunction(['/', '%']); const divisionTryToHug = createHugFunction(['*', '%']); const moduloTryToHug = createHugFunction(['*', '/', '%']); +export const printMultiplicativeExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.AdditiveExpression, + NonterminalKind.ShiftExpression, + NonterminalKind.BitwiseAndExpression, + NonterminalKind.BitwiseOrExpression, + NonterminalKind.BitwiseXorExpression, + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class MultiplicativeExpression implements SlangNode { readonly kind = NonterminalKind.MultiplicativeExpression; @@ -61,6 +76,6 @@ export class MultiplicativeExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printMultiplicativeExpression(this, path, print, options); } } diff --git a/src/slang-nodes/ShiftExpression.ts b/src/slang-nodes/ShiftExpression.ts index 21b3cec64..8f33c9d8d 100644 --- a/src/slang-nodes/ShiftExpression.ts +++ b/src/slang-nodes/ShiftExpression.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printBinaryOperation } from '../slang-printers/print-binary-operation.js'; import { createHugFunction } from '../slang-utils/create-hug-function.js'; +import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js'; import { Expression } from './Expression.js'; @@ -20,6 +21,18 @@ const tryToHugLeftOperand = createHugFunction([ ]); const tryToHugRightOperand = createHugFunction(['+', '-', '*', '/', '**']); +const printShiftExpression = printBinaryOperation( + createKindCheckFunction([ + NonterminalKind.BitwiseAndExpression, + NonterminalKind.BitwiseOrExpression, + NonterminalKind.BitwiseXorExpression, + NonterminalKind.InequalityExpression, + NonterminalKind.EqualityExpression, + NonterminalKind.AndExpression, + NonterminalKind.OrExpression + ]) +); + export class ShiftExpression implements SlangNode { readonly kind = NonterminalKind.ShiftExpression; @@ -54,6 +67,6 @@ export class ShiftExpression implements SlangNode { print: PrintFunction, options: ParserOptions ): Doc { - return printBinaryOperation(this, path, print, options); + return printShiftExpression(this, path, print, options); } } diff --git a/src/slang-printers/create-binary-operation-printer.ts b/src/slang-printers/create-binary-operation-printer.ts index 2d327acaa..4c7b6dc49 100644 --- a/src/slang-printers/create-binary-operation-printer.ts +++ b/src/slang-printers/create-binary-operation-printer.ts @@ -17,8 +17,11 @@ function rightOperandPrint( path: AstPath, print: PrintFunction ): Doc { - const rightOperand = [line, path.call(print, 'rightOperand')]; - + const rightOperand = [ + ` ${node.operator}`, + line, + path.call(print, 'rightOperand') + ]; // If it's a single binary operation, avoid having a small right // operand like - 1 on its own line const shouldGroup = @@ -51,7 +54,6 @@ export const createBinaryOperationPrinter = return groupRules([ path.call(print, 'leftOperand'), - ` ${node.operator}`, indentRules(rightOperandPrint(node, path, print)) ]); }; diff --git a/src/slang-printers/print-binary-operation.ts b/src/slang-printers/print-binary-operation.ts index 010a3b5e7..cb0504c97 100644 --- a/src/slang-printers/print-binary-operation.ts +++ b/src/slang-printers/print-binary-operation.ts @@ -2,59 +2,69 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { createBinaryOperationPrinter } from './create-binary-operation-printer.js'; import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; +import { isBinaryOperation } from '../slang-utils/is-binary-operation.js'; -import type { AstPath, Doc } from 'prettier'; -import type { BinaryOperation, StrictAstNode } from '../slang-nodes/types.d.ts'; -import type { EqualityExpression } from '../slang-nodes/EqualityExpression.ts'; -import type { InequalityExpression } from '../slang-nodes/InequalityExpression.ts'; +import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { + AstNode, + BinaryOperation, + StrictAstNode +} from '../slang-nodes/types.d.ts'; +import type { PrintFunction } from '../types.js'; const { group, indent } = doc.builders; -const isBinaryOperationWithoutComparison = createKindCheckFunction([ - NonterminalKind.AdditiveExpression, - NonterminalKind.MultiplicativeExpression, - NonterminalKind.ExponentiationExpression, - NonterminalKind.AssignmentExpression, - NonterminalKind.BitwiseAndExpression, - NonterminalKind.BitwiseOrExpression, - NonterminalKind.BitwiseXorExpression, - NonterminalKind.AndExpression, - NonterminalKind.OrExpression, - NonterminalKind.ShiftExpression -]) as ( - node: StrictAstNode -) => node is Exclude< - BinaryOperation, - EqualityExpression | InequalityExpression ->; - -const binaryGroupRulesBuilder = +export const binaryGroupRulesBuilder = + (shouldGroup: (node: BinaryOperation) => boolean) => (path: AstPath) => (document: Doc): Doc => { const grandparentNode = path.getNode(2) as StrictAstNode; - if (isBinaryOperationWithoutComparison(grandparentNode)) { - return document; - } - return group(document); + if (!isBinaryOperation(grandparentNode)) return group(document); + if (shouldGroup(grandparentNode)) return group(document); + return document; }; -const binaryIndentRulesBuilder = +const isStatementWithoutIndentedOperation = createKindCheckFunction([ + NonterminalKind.ReturnStatement, + NonterminalKind.IfStatement, + NonterminalKind.WhileStatement +]); + +export const shouldNotIndent = ( + node: StrictAstNode, + path: AstPath, + index: number +): boolean => + isStatementWithoutIndentedOperation(node) || + (node.kind === NonterminalKind.ExpressionStatement && + (path.getNode(index + 1) as StrictAstNode).kind === + NonterminalKind.ForStatementCondition); + +export const binaryIndentRulesBuilder = + (shouldIndent: (node: BinaryOperation) => boolean) => (path: AstPath) => (document: Doc): Doc => { let node = path.getNode() as StrictAstNode; for (let i = 2; ; i += 2) { const grandparentNode = path.getNode(i) as StrictAstNode; - if (grandparentNode.kind === NonterminalKind.ReturnStatement) break; - if (!isBinaryOperationWithoutComparison(grandparentNode)) { - return indent(document); - } + if (shouldNotIndent(grandparentNode, path, i)) break; + if (!isBinaryOperation(grandparentNode)) return indent(document); + if (shouldIndent(grandparentNode)) return indent(document); if (node === grandparentNode.rightOperand.variant) break; node = grandparentNode; } return document; }; -export const printBinaryOperation = createBinaryOperationPrinter( - binaryGroupRulesBuilder, - binaryIndentRulesBuilder -); +export const printBinaryOperation = ( + shouldGroupAndIndent: (node: StrictAstNode) => boolean +): (( + node: BinaryOperation, + path: AstPath, + print: PrintFunction, + options: ParserOptions +) => Doc) => + createBinaryOperationPrinter( + binaryGroupRulesBuilder(shouldGroupAndIndent), + binaryIndentRulesBuilder(shouldGroupAndIndent) + ); diff --git a/src/slang-printers/print-comparison-operation.ts b/src/slang-printers/print-comparison-operation.ts deleted file mode 100644 index 6db056370..000000000 --- a/src/slang-printers/print-comparison-operation.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { doc } from 'prettier'; -import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; -import { isBinaryOperation } from '../slang-utils/is-binary-operation.js'; -import { createBinaryOperationPrinter } from './create-binary-operation-printer.js'; - -import type { AstPath, Doc } from 'prettier'; -import type { BinaryOperation, StrictAstNode } from '../slang-nodes/types.d.ts'; - -const { group, indent } = doc.builders; - -const isStatementWithoutIndentedOperation = createKindCheckFunction([ - NonterminalKind.ReturnStatement, - NonterminalKind.IfStatement, - NonterminalKind.WhileStatement -]); - -const comparisonIndentRulesBuilder = - (path: AstPath) => - (document: Doc): Doc => { - let node = path.getNode() as StrictAstNode; - for (let i = 2; ; i += 2) { - const grandparentNode = path.getNode(i) as StrictAstNode; - if (grandparentNode.kind === NonterminalKind.ExpressionStatement) { - if ( - (path.getNode(i + 1) as StrictAstNode).kind === - NonterminalKind.ForStatementCondition - ) - break; - else return indent(document); - } - if (isStatementWithoutIndentedOperation(grandparentNode)) break; - if (!isBinaryOperation(grandparentNode)) return indent(document); - if (node === grandparentNode.rightOperand.variant) break; - node = grandparentNode; - } - return document; - }; - -export const printComparisonOperation = createBinaryOperationPrinter( - () => - (document: Doc): Doc => - group(document), // always group - comparisonIndentRulesBuilder -); diff --git a/src/slang-printers/print-logical-operation.ts b/src/slang-printers/print-logical-operation.ts index d0b8b7547..3934842ce 100644 --- a/src/slang-printers/print-logical-operation.ts +++ b/src/slang-printers/print-logical-operation.ts @@ -1,8 +1,11 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js'; import { isBinaryOperation } from '../slang-utils/is-binary-operation.js'; import { createBinaryOperationPrinter } from './create-binary-operation-printer.js'; +import { + binaryGroupRulesBuilder, + shouldNotIndent +} from './print-binary-operation.js'; import type { AstPath, Doc, ParserOptions } from 'prettier'; import type { @@ -11,20 +14,9 @@ import type { StrictAstNode } from '../slang-nodes/types.d.ts'; -const { group, indent } = doc.builders; +const { indent } = doc.builders; -const isStatementWithoutIndentedOperation = createKindCheckFunction([ - NonterminalKind.ReturnStatement, - NonterminalKind.IfStatement, - NonterminalKind.WhileStatement -]); - -const logicalGroupRulesBuilder = - (path: AstPath) => - (document: Doc): Doc => - isBinaryOperation(path.getNode(2) as StrictAstNode) - ? document - : group(document); +const logicalGroupRulesBuilder = binaryGroupRulesBuilder(() => false); const logicalIndentRulesBuilder = (path: AstPath, options: ParserOptions) => @@ -32,7 +24,7 @@ const logicalIndentRulesBuilder = let node = path.getNode() as StrictAstNode; for (let i = 2; ; i += 2) { const grandparentNode = path.getNode(i) as StrictAstNode; - if (isStatementWithoutIndentedOperation(grandparentNode)) break; + if (shouldNotIndent(grandparentNode, path, i)) break; if ( options.experimentalTernaries && grandparentNode.kind === NonterminalKind.ConditionalExpression && diff --git a/tests/format/BinaryOperationHierarchy/__snapshots__/format.test.js.snap b/tests/format/BinaryOperationHierarchy/__snapshots__/format.test.js.snap index 67b184d15..f6188a900 100644 --- a/tests/format/BinaryOperationHierarchy/__snapshots__/format.test.js.snap +++ b/tests/format/BinaryOperationHierarchy/__snapshots__/format.test.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,12 @@ contract Group { veryVeryVeryLongUint256A == veryVeryVeryLongUint256B ^ veryVeryVeryLongUint256C; resultBoolean = - veryVeryVeryLongUint256A == veryVeryVeryLongUint256B == + veryVeryVeryLongUint256A == + veryVeryVeryLongUint256B == veryVeryVeryLongBooleanC; resultBoolean = - veryVeryVeryLongUint256A == veryVeryVeryLongUint256B != + veryVeryVeryLongUint256A == + veryVeryVeryLongUint256B != veryVeryVeryLongBooleanC; resultBoolean = veryVeryVeryLongBooleanA == @@ -1083,10 +1067,12 @@ contract Group { veryVeryVeryLongUint256A != veryVeryVeryLongUint256B ^ veryVeryVeryLongUint256C; resultBoolean = - veryVeryVeryLongUint256A != veryVeryVeryLongUint256B == + veryVeryVeryLongUint256A != + veryVeryVeryLongUint256B == veryVeryVeryLongBooleanC; resultBoolean = - veryVeryVeryLongUint256A != veryVeryVeryLongUint256B != + veryVeryVeryLongUint256A != + veryVeryVeryLongUint256B != veryVeryVeryLongBooleanC; resultBoolean = veryVeryVeryLongBooleanA != @@ -1691,8 +1677,8 @@ contract Indent { function exp() public { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ** - (veryVeryVeryExtremelyExtremelyLongUint256B ** - veryVeryVeryExtremelyExtremelyLongUint256C); + (veryVeryVeryExtremelyExtremelyLongUint256B ** + veryVeryVeryExtremelyExtremelyLongUint256C); resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ** veryVeryVeryExtremelyExtremelyLongUint256B * @@ -1778,11 +1764,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A * - veryVeryVeryExtremelyExtremelyLongUint256B + + veryVeryVeryExtremelyExtremelyLongUint256B + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A * - veryVeryVeryExtremelyExtremelyLongUint256B - + veryVeryVeryExtremelyExtremelyLongUint256B - veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = (veryVeryVeryExtremelyExtremelyLongUint256A * @@ -1849,11 +1835,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A / - veryVeryVeryExtremelyExtremelyLongUint256B + + veryVeryVeryExtremelyExtremelyLongUint256B + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A / - veryVeryVeryExtremelyExtremelyLongUint256B - + veryVeryVeryExtremelyExtremelyLongUint256B - veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = (veryVeryVeryExtremelyExtremelyLongUint256A / @@ -1928,23 +1914,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 +1966,11 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + veryVeryVeryExtremelyExtremelyLongUint256B * - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + veryVeryVeryExtremelyExtremelyLongUint256B / - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A + (veryVeryVeryExtremelyExtremelyLongUint256B % @@ -2051,11 +2037,11 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - veryVeryVeryExtremelyExtremelyLongUint256B * - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - veryVeryVeryExtremelyExtremelyLongUint256B / - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A - (veryVeryVeryExtremelyExtremelyLongUint256B % @@ -2130,7 +2116,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A << veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A << (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2201,7 +2187,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A >> veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A >> (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2272,7 +2258,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A & veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A & (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2343,7 +2329,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A | veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A | (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2414,7 +2400,7 @@ contract Indent { resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ^ veryVeryVeryExtremelyExtremelyLongUint256B % - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultUint256 = veryVeryVeryExtremelyExtremelyLongUint256A ^ (veryVeryVeryExtremelyExtremelyLongUint256B + @@ -2525,19 +2511,19 @@ contract Indent { resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B < - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B <= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B > - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA == veryVeryVeryExtremelyExtremelyLongUint256B >= - veryVeryVeryExtremelyExtremelyLongUint256C; + veryVeryVeryExtremelyExtremelyLongUint256C; } function notEqual() public { @@ -2596,19 +2582,19 @@ contract Indent { 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 +2644,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A < - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A < - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2713,11 +2699,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A <= - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A <= - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2768,11 +2754,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A > - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A > - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2823,11 +2809,11 @@ contract Indent { veryVeryVeryExtremelyExtremelyLongUint256C; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A >= - veryVeryVeryExtremelyExtremelyLongUint256B == + veryVeryVeryExtremelyExtremelyLongUint256B == veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongUint256A >= - veryVeryVeryExtremelyExtremelyLongUint256B != + veryVeryVeryExtremelyExtremelyLongUint256B != veryVeryVeryExtremelyExtremelyLongBooleanC; } @@ -2843,11 +2829,11 @@ contract Indent { resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA || veryVeryVeryExtremelyExtremelyLongBooleanB == - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = veryVeryVeryExtremelyExtremelyLongBooleanA || veryVeryVeryExtremelyExtremelyLongBooleanB != - veryVeryVeryExtremelyExtremelyLongBooleanC; + veryVeryVeryExtremelyExtremelyLongBooleanC; resultBoolean = (veryVeryVeryExtremelyExtremelyLongBooleanA && veryVeryVeryExtremelyExtremelyLongBooleanB) || @@ -2859,26 +2845,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__/format.test.js.snap b/tests/format/BinaryOperators/__snapshots__/format.test.js.snap index 7efb36ef2..fb57f74ad 100644 --- a/tests/format/BinaryOperators/__snapshots__/format.test.js.snap +++ b/tests/format/BinaryOperators/__snapshots__/format.test.js.snap @@ -257,9 +257,9 @@ contract ArithmeticOperators { veryVeryVeryVeryVeryLongVariableCalledB ) + c * - veryVeryVeryVeryVeryLongFunctionCalledA( - veryVeryVeryVeryVeryLongVariableCalledB - ) - + veryVeryVeryVeryVeryLongFunctionCalledA( + veryVeryVeryVeryVeryLongVariableCalledB + ) - d; a = veryVeryVeryVeryVeryLongFunctionCalledA( @@ -306,7 +306,7 @@ contract ArithmeticOperators { veryVeryVeryVeryVeryLongVariableCalledB; a = veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledB; a = veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB * @@ -324,13 +324,13 @@ contract ArithmeticOperators { for ( a = veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledB; a <= veryVeryVeryVeryVeryLongVariableCalledA ** veryVeryVeryVeryVeryLongVariableCalledB; a += veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB + veryVeryVeryVeryVeryLongVariableCalledB ) {} a( veryVeryVeryVeryVeryLongVariableCalledA ** @@ -338,7 +338,7 @@ contract ArithmeticOperators { ); return veryVeryVeryVeryVeryLongVariableCalledA ** - veryVeryVeryVeryVeryLongVariableCalledB; + veryVeryVeryVeryVeryLongVariableCalledB; veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) ** c; @@ -354,7 +354,7 @@ contract ArithmeticOperators { veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) ** - c; + c; if ( veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB @@ -505,7 +505,7 @@ contract ComparisonOperators { veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB ) > - d; + d; a = veryVeryVeryVeryVeryLongFunctionCalledA( veryVeryVeryVeryVeryLongVariableCalledB diff --git a/tests/format/ContractDefinitions/__snapshots__/format.test.js.snap b/tests/format/ContractDefinitions/__snapshots__/format.test.js.snap index eeb743101..bc993a837 100644 --- a/tests/format/ContractDefinitions/__snapshots__/format.test.js.snap +++ b/tests/format/ContractDefinitions/__snapshots__/format.test.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__/format.test.js.snap b/tests/format/ExperimentalTernaries/__snapshots__/format.test.js.snap index 3d76e3977..009eb2836 100644 --- a/tests/format/ExperimentalTernaries/__snapshots__/format.test.js.snap +++ b/tests/format/ExperimentalTernaries/__snapshots__/format.test.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"