From b98cf672a911846fbb29ac6a9a839fd93d901daa Mon Sep 17 00:00:00 2001 From: Jordan Kiesel Date: Wed, 2 Aug 2023 20:05:29 -0600 Subject: [PATCH] feat: improve binary expression formatting --- .../src/printers/comments/handle-comments.ts | 106 ++++++++--- .../src/printers/expressions.ts | 150 ++++++---------- .../src/printers/printer-utils.ts | 165 +++++++++++------- .../unit-test/binary_expressions/_input.java | 47 +++++ .../unit-test/binary_expressions/_output.java | 65 +++++++ .../test/unit-test/expressions/_output.java | 85 +++------ .../test/unit-test/sealed/_output.java | 2 +- 7 files changed, 376 insertions(+), 244 deletions(-) diff --git a/packages/prettier-plugin-java/src/printers/comments/handle-comments.ts b/packages/prettier-plugin-java/src/printers/comments/handle-comments.ts index 59ae4616..4348acf7 100644 --- a/packages/prettier-plugin-java/src/printers/comments/handle-comments.ts +++ b/packages/prettier-plugin-java/src/printers/comments/handle-comments.ts @@ -1,44 +1,98 @@ -import { hasLeadingComments } from "./comments-utils"; -import { BinaryExpressionCtx, IToken } from "java-parser"; +import { hasLeadingComments, hasTrailingComments } from "./comments-utils"; +import { + BinaryExpressionCtx, + IToken, + UnaryExpressionCstNode +} from "java-parser"; export function handleCommentsBinaryExpression(ctx: BinaryExpressionCtx) { + moveOperatorLeadingCommentsToNextExpression(ctx); + moveExpressionTrailingCommentsToNextOperator(ctx); +} + +function moveOperatorLeadingCommentsToNextExpression(ctx: BinaryExpressionCtx) { let unaryExpressionIndex = 1; - if (ctx.BinaryOperator !== undefined) { - ctx.BinaryOperator.forEach(binaryOperator => { - if (hasLeadingComments(binaryOperator)) { + ctx.BinaryOperator?.forEach(binaryOperator => { + if (hasLeadingComments(binaryOperator)) { + while ( + ctx.unaryExpression[unaryExpressionIndex].location.startOffset < + binaryOperator.endOffset + ) { + unaryExpressionIndex++; + } + + // Adapt the position of the operator and its leading comments + const shiftUp = + binaryOperator.leadingComments[0].startLine - + 1 - + binaryOperator.startLine; + + if ( + binaryOperator.startLine !== + ctx.unaryExpression[unaryExpressionIndex].location.startLine + ) { + binaryOperator.leadingComments.forEach(comment => { + comment.startLine += 1; + comment.endLine += 1; + }); + } + binaryOperator.startLine += shiftUp; + binaryOperator.endLine += shiftUp; + + // Move binaryOperator's leading comments to the following + // unaryExpression + ctx.unaryExpression[unaryExpressionIndex].leadingComments = + ctx.unaryExpression[unaryExpressionIndex].leadingComments || []; + ctx.unaryExpression[unaryExpressionIndex].leadingComments!.unshift( + ...binaryOperator.leadingComments + ); + delete (binaryOperator as IToken).leadingComments; + } + }); +} + +function moveExpressionTrailingCommentsToNextOperator( + ctx: BinaryExpressionCtx +) { + const binaryOperators = ctx.BinaryOperator; + let binaryOperatorIndex = 1; + if (binaryOperators?.length) { + ctx.unaryExpression.forEach(unaryExpression => { + if (hasTrailingComments(unaryExpression)) { while ( - ctx.unaryExpression[unaryExpressionIndex].location.startOffset < - binaryOperator.endOffset + binaryOperatorIndex < binaryOperators.length && + unaryExpression.location.endOffset && + binaryOperators[binaryOperatorIndex].startOffset < + unaryExpression.location.endOffset ) { - unaryExpressionIndex++; + binaryOperatorIndex++; } + const binaryOperator = binaryOperators[binaryOperatorIndex]; - // Adapt the position of the operator and its leading comments + // Adapt the position of the expression and its trailing comments const shiftUp = - binaryOperator.leadingComments[0].startLine - + unaryExpression.trailingComments[0].startLine - 1 - - binaryOperator.startLine; + unaryExpression.location.startLine; - if ( - binaryOperator.startLine !== - ctx.unaryExpression[unaryExpressionIndex].location.startLine - ) { - binaryOperator.leadingComments.forEach(comment => { + if (unaryExpression.location.startLine !== binaryOperator.startLine) { + unaryExpression.trailingComments.forEach(comment => { comment.startLine += 1; comment.endLine += 1; }); } - binaryOperator.startLine += shiftUp; - binaryOperator.endLine += shiftUp; - - // Assign the leading comments & trailing comments of the binaryOperator - // to the following unaryExpression as leading comments - ctx.unaryExpression[unaryExpressionIndex].leadingComments = - ctx.unaryExpression[unaryExpressionIndex].leadingComments || []; - ctx.unaryExpression[unaryExpressionIndex].leadingComments!.unshift( - ...binaryOperator.leadingComments + unaryExpression.location.startLine += shiftUp; + if (unaryExpression.location.endLine !== undefined) { + unaryExpression.location.endLine += shiftUp; + } + + // Move unaryExpression's trailing comments to the following + // binaryOperator + binaryOperator.trailingComments = binaryOperator.trailingComments ?? []; + binaryOperator.trailingComments.unshift( + ...unaryExpression.trailingComments ); - delete (binaryOperator as IToken).leadingComments; + delete (unaryExpression as UnaryExpressionCstNode).trailingComments; } }); } diff --git a/packages/prettier-plugin-java/src/printers/expressions.ts b/packages/prettier-plugin-java/src/printers/expressions.ts index 0f386b7e..4cdb8919 100644 --- a/packages/prettier-plugin-java/src/printers/expressions.ts +++ b/packages/prettier-plugin-java/src/printers/expressions.ts @@ -41,7 +41,6 @@ import { ReferenceTypeCastExpressionCtx, RegularLambdaParameterCtx, TernaryExpressionCtx, - TypeArgumentListCtx, TypeArgumentsOrDiamondCtx, TypePatternCtx, UnaryExpressionCtx, @@ -50,7 +49,6 @@ import { } from "java-parser/api"; import forEach from "lodash/forEach"; -import { Doc } from "prettier"; import { builders } from "prettier/doc"; import { BaseCstPrettierPrinter } from "../base-cst-printer"; import { isAnnotationCstNode } from "../types/utils"; @@ -63,20 +61,18 @@ import { printTokenWithComments } from "./comments/format-comments"; import { handleCommentsBinaryExpression } from "./comments/handle-comments"; import { concat, dedent, group, indent } from "./prettier-builder"; import { + binary, findDeepElementInPartsArray, isExplicitLambdaParameter, - isShiftOperator, isUniqueMethodInvocation, - matchCategory, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, - separateTokensIntoGroups, sortAnnotationIdentifier, - sortNodes + sortNodes, + sortTokens } from "./printer-utils"; -import join = builders.join; const { ifBreak, line, softline, indentIfBreak } = builders; @@ -244,104 +240,54 @@ export class ExpressionsPrettierVisitor extends BaseCstPrettierPrinter { return binaryExpression; } - binaryExpression(ctx: BinaryExpressionCtx, params: any) { + binaryExpression( + ctx: BinaryExpressionCtx, + params?: { addParenthesisToWrapStatement?: boolean } + ) { handleCommentsBinaryExpression(ctx); - const instanceofReferences = this.mapVisit( - sortNodes([ctx.pattern, ctx.referenceType]) - ); - const expression = this.mapVisit(ctx.expression); - const unaryExpression = this.mapVisit(ctx.unaryExpression); - - const { groupsOfOperator, sortedBinaryOperators } = - separateTokensIntoGroups(ctx); - const segmentsSplitByBinaryOperator: any[] = []; - let currentSegment = []; + const sortedNodes = sortNodes([ + ctx.pattern, + ctx.referenceType, + ctx.expression, + ctx.unaryExpression + ]); - if (groupsOfOperator.length === 1 && groupsOfOperator[0].length === 0) { - return unaryExpression.shift(); - } + const nodes = this.mapVisit( + sortedNodes, + sortedNodes.length === 1 ? params : undefined + ); + const tokens = sortTokens([ + ctx.Instanceof, + ctx.AssignmentOperator, + ctx.Less, + ctx.Greater, + ctx.BinaryOperator + ]); + const hasTokens = tokens.length > 0; - groupsOfOperator.forEach(subgroup => { - currentSegment = [unaryExpression.shift()]; - for (let i = 0; i < subgroup.length; i++) { - const token = subgroup[i]; - const shiftOperator = isShiftOperator(subgroup, i); - if (token.tokenType.name === "Instanceof") { - currentSegment.push( - rejectAndJoin(" ", [ - ctx.Instanceof![0], - instanceofReferences.shift() - ]) - ); - } else if (matchCategory(token, "'AssignmentOperator'")) { - currentSegment.push( - indent(rejectAndJoin(line, [token, expression.shift()])) - ); - } else if ( - shiftOperator === "leftShift" || - shiftOperator === "rightShift" - ) { - currentSegment.push( - rejectAndJoin(" ", [ - rejectAndConcat([token, subgroup[i + 1]]), - unaryExpression.shift() - ]) - ); - i++; - } else if (shiftOperator === "doubleRightShift") { - currentSegment.push( - rejectAndJoin(" ", [ - rejectAndConcat([token, subgroup[i + 1], subgroup[i + 2]]), - unaryExpression.shift() - ]) - ); - i += 2; - } else if (matchCategory(token, "'BinaryOperator'")) { - currentSegment.push( - rejectAndJoin(line, [token, unaryExpression.shift()]) - ); - } - } - segmentsSplitByBinaryOperator.push( - group(rejectAndJoin(" ", currentSegment)) - ); - }); + const content = binary(nodes, tokens, true); - if (params !== undefined && params.addParenthesisToWrapStatement) { - return group( - concat([ - ifBreak("(", ""), - indent( - concat([ - softline, - group( - rejectAndJoinSeps( - sortedBinaryOperators.map(elt => concat([" ", elt, line])), - segmentsSplitByBinaryOperator - ) - ) - ]) - ), - softline, - ifBreak(")") - ]) - ); - } - - return group( - rejectAndJoinSeps( - sortedBinaryOperators.map(elt => concat([" ", elt, line])), - segmentsSplitByBinaryOperator - ) - ); + return hasTokens && params?.addParenthesisToWrapStatement + ? group( + concat([ + ifBreak("("), + indent(concat([softline, content])), + softline, + ifBreak(")") + ]) + ) + : content; } - unaryExpression(ctx: UnaryExpressionCtx) { + unaryExpression( + ctx: UnaryExpressionCtx, + params?: { addParenthesisToWrapStatement?: boolean } + ) { const unaryPrefixOperator = ctx.UnaryPrefixOperator ? ctx.UnaryPrefixOperator : []; - const primary = this.visit(ctx.primary); + const primary = this.visit(ctx.primary, params); const unarySuffixOperator = ctx.UnarySuffixOperator ? ctx.UnarySuffixOperator : []; @@ -369,10 +315,14 @@ export class ExpressionsPrettierVisitor extends BaseCstPrettierPrinter { ]); } - primary(ctx: PrimaryCtx) { + primary( + ctx: PrimaryCtx, + params?: { addParenthesisToWrapStatement?: boolean } + ) { const countMethodInvocation = isUniqueMethodInvocation(ctx.primarySuffix); const primaryPrefix = this.visit(ctx.primaryPrefix, { + ...params, shouldBreakBeforeFirstMethodInvocation: countMethodInvocation > 1 }); @@ -561,9 +511,13 @@ export class ExpressionsPrettierVisitor extends BaseCstPrettierPrinter { return rejectAndConcat([keyWord, typeArguments]); } - parenthesisExpression(ctx: ParenthesisExpressionCtx) { + parenthesisExpression( + ctx: ParenthesisExpressionCtx, + params?: { addParenthesisToWrapStatement?: boolean } + ) { const expression = this.visit(ctx.expression); - return putIntoBraces(expression, softline, ctx.LBrace[0], ctx.RBrace[0]); + const separator = params?.addParenthesisToWrapStatement ? softline : ""; + return putIntoBraces(expression, separator, ctx.LBrace[0], ctx.RBrace[0]); } castExpression(ctx: CastExpressionCtx) { diff --git a/packages/prettier-plugin-java/src/printers/printer-utils.ts b/packages/prettier-plugin-java/src/printers/printer-utils.ts index aef304be..cbb58f06 100644 --- a/packages/prettier-plugin-java/src/printers/printer-utils.ts +++ b/packages/prettier-plugin-java/src/printers/printer-utils.ts @@ -1,6 +1,5 @@ import { AnnotationCstNode, - BinaryExpressionCtx, ClassBodyDeclarationCstNode, ConstantModifierCstNode, CstElement, @@ -144,7 +143,7 @@ export function sortAnnotationIdentifier( }); } -function sortTokens(values: (IToken[] | undefined)[]): IToken[] { +export function sortTokens(values: (IToken[] | undefined)[]): IToken[] { let tokens: IToken[] = []; forEach(values, argument => { @@ -594,73 +593,121 @@ export function putIntoBraces( ); } -const andOrBinaryOperators = ["&&", "||", "&", "|", "^"]; +export function binary(nodes: Doc[], tokens: IToken[], isRoot = false): Doc { + let levelOperator: string | undefined; + let levelPrecedence: number | undefined; + let level: Doc[] = []; + while (tokens.length) { + const nextOperator = getOperator(tokens); + const nextPrecedence = getOperatorPrecedence(nextOperator); -export function separateTokensIntoGroups(ctx: BinaryExpressionCtx) { - /** - * separate tokens into groups by andOrBinaryOperators ("&&", "||", "&", "|", "^") - * in order to break those operators in priority. - */ - const tokens = sortTokens([ - ctx.Instanceof, - ctx.AssignmentOperator, - ctx.Less, - ctx.Greater, - ctx.BinaryOperator - ]); - - const groupsOfOperator: IToken[][] = []; - const sortedBinaryOperators: IToken[] = []; - let tmpGroup: IToken[] = []; - tokens.forEach(token => { - if ( - matchCategory(token, "'BinaryOperator'") && - includes(andOrBinaryOperators, token.image) - ) { - sortedBinaryOperators.push(token); - groupsOfOperator.push(tmpGroup); - tmpGroup = []; + if (levelPrecedence === undefined || nextPrecedence === levelPrecedence) { + const tokenLength = ["<<", ">>", ">>>"].includes(nextOperator) + ? nextOperator.length + : 1; + const operator = concat(tokens.splice(0, tokenLength)); + if ( + levelOperator !== undefined && + needsParentheses(levelOperator, nextOperator) + ) { + level.push(nodes.shift()!); + level = [ + concat(["(", group(indent(join(line, level))), ") ", operator]) + ]; + } else { + level.push(join(" ", [nodes.shift()!, operator])); + } + levelOperator = nextOperator; + levelPrecedence = nextPrecedence; + } else if (nextPrecedence < levelPrecedence) { + level.push(nodes.shift()!); + if (isRoot) { + const content = group(indent(join(line, level))); + nodes.unshift( + levelOperator !== undefined && + needsParentheses(levelOperator, nextOperator) + ? concat(["(", content, ")"]) + : content + ); + level = []; + levelOperator = undefined; + levelPrecedence = undefined; + } else { + return group(join(line, level)); + } } else { - tmpGroup.push(token); + const content = indent(binary(nodes, tokens)); + nodes.unshift( + levelOperator !== undefined && + needsParentheses(nextOperator, levelOperator) + ? concat(["(", content, ")"]) + : content + ); } - }); - - groupsOfOperator.push(tmpGroup); - - return { - groupsOfOperator, - sortedBinaryOperators - }; + } + level.push(nodes.shift()!); + return group(join(line, level)); } -export function isShiftOperator(tokens: IToken[], index: number) { - if (tokens.length <= index + 1) { - return "none"; +function getOperator(tokens: IToken[]) { + if (!tokens.length) { + return ""; } - - if ( - tokens[index].image === "<" && - tokens[index + 1].image === "<" && - tokens[index].startOffset === tokens[index + 1].startOffset - 1 - ) { - return "leftShift"; + const [{ image, startOffset }] = tokens; + if (!["<", ">"].includes(image)) { + return image; } - if ( - tokens[index].image === ">" && - tokens[index + 1].image === ">" && - tokens[index].startOffset === tokens[index + 1].startOffset - 1 - ) { - if ( - tokens.length > index + 2 && - tokens[index + 2].image === ">" && - tokens[index + 1].startOffset === tokens[index + 2].startOffset - 1 - ) { - return "doubleRightShift"; + let repeatedTokenCount = 1; + for (let i = 1; i < Math.min(3, tokens.length); i++) { + const token = tokens[i]; + if (token.image !== image || token.startOffset !== startOffset + i) { + break; } - return "rightShift"; + repeatedTokenCount++; } + if (repeatedTokenCount === 1) { + return image; + } + if (image === "<") { + return "<<"; + } else if (repeatedTokenCount == 2) { + return ">>"; + } else { + return ">>>"; + } +} - return "none"; +const PRECEDENCES_BY_OPERATOR = new Map( + [ + ["||"], + ["&&"], + ["|"], + ["^"], + ["&"], + ["==", "!="], + ["<", ">", "<=", ">=", "instanceof"], + ["<<", ">>", ">>>"], + ["+", "-"], + ["*", "/", "%"] + ].flatMap((operators, index) => operators.map(operator => [operator, index])) +); +function getOperatorPrecedence(operator: string) { + return PRECEDENCES_BY_OPERATOR.get(operator) ?? -1; +} + +function needsParentheses(operator: string, parentOperator: string) { + return ( + (operator === "&&" && parentOperator === "||") || + (["|", "^", "&", "<<", ">>", ">>>"].includes(parentOperator) && + getOperatorPrecedence(operator) > + getOperatorPrecedence(parentOperator)) || + [operator, parentOperator].every(o => ["==", "!="].includes(o)) || + [operator, parentOperator].every(o => ["<<", ">>", ">>>"].includes(o)) || + (operator === "*" && parentOperator === "/") || + (operator === "/" && parentOperator === "*") || + (operator === "%" && ["+", "-", "*", "/"].includes(parentOperator)) || + (["*", "/"].includes(operator) && parentOperator === "%") + ); } export function isStatementEmptyStatement(statement: Doc) { diff --git a/packages/prettier-plugin-java/test/unit-test/binary_expressions/_input.java b/packages/prettier-plugin-java/test/unit-test/binary_expressions/_input.java index acd0bf7c..05535dd1 100644 --- a/packages/prettier-plugin-java/test/unit-test/binary_expressions/_input.java +++ b/packages/prettier-plugin-java/test/unit-test/binary_expressions/_input.java @@ -62,4 +62,51 @@ public void method() { public void binaryExpressionWithCast() { double availability = (double) successfulCount / (successfulCount + failureCount); } + + void parentheses() { + var result = a + b >>> 1; + var sizeIndex = index - 1 >>> level & MASK; + var from = offset > left ? 0 : left - offset >> level; + var to = right - offset >> level + 1; + if (rawIndex < 1 << list._level + SHIFT) {} + var res = size < SIZE ? 0 : size - 1 >>> SHIFT << SHIFT; + sign = 1 - 2 * b[3] >> 7; + exponent = b[3] << 1 & 0xff | b[2] >> 7 - 127; + mantissa = b[2] & 0x7f << 16 | b[1] << 8 | b[0]; + + 2 / 3 * 10 / 2 + 2; + 2 * 3 * 10 / 2 + 2; + var rotateX = RANGE / rect.height * refY - RANGE / 2 * getXMultiplication(rect.width); + var rotateY = RANGE / rect.width * refX - RANGE / 2 * getYMultiplication(rect.width); + + a % 10 - 5; + a - 10 % 5; + a * b % 10; + a % b * 10; + a % 10 > 5; + a % 10 == 0; + + 1 << 2 >>> 3 >> 4; + 1 >>> 2 >> 3 << 4; + + 1 << 2 + 3; + 1 >> 2 - 3; + 1 >>> 2 * 3; + 1 / 2 << 3; + 1 + 2 >> 3; + 1 - 2 >>> 3; + + x == y == z; + x != y == z; + x == y != z; + x != y != z; + + 1 & 2 == 3; + + if (aaaaaaaaaa + bbbbbbbbbb == cccccccccc + dddddddddd && eeeeeeeeee + ffffffffff == gggggggggg + hhhhhhhhhh || iiiiiiiiii) {} + + if (a * b + c << d < e == f & g ^ h | i && j || k && l | m ^ n & o != p > q >> r - s / t) {} + + if (aaaaaaaaaa + bbbbbbbbbb == cccccccccc + dddddddddd && eeeeeeeeee + ffffffffff == gggggggggg + hhhhhhhhhh || iiiiiiiiii + jjjjjjjjjj == kkkkkkkkkk + llllllllll && mmmmmmmmmm + nnnnnnnnnn == oooooooooo + pppppppppp || qqqqqqqqqq + rrrrrrrrrr == ssssssssss + tttttttttt && uuuuuuuuuu + vvvvvvvvvv == wwwwwwwwww + xxxxxxxxxxx) {} + } } diff --git a/packages/prettier-plugin-java/test/unit-test/binary_expressions/_output.java b/packages/prettier-plugin-java/test/unit-test/binary_expressions/_output.java index 1c2c35cb..0c1bd482 100644 --- a/packages/prettier-plugin-java/test/unit-test/binary_expressions/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/binary_expressions/_output.java @@ -87,4 +87,69 @@ public void binaryExpressionWithCast() { double availability = (double) successfulCount / (successfulCount + failureCount); } + + void parentheses() { + var result = (a + b) >>> 1; + var sizeIndex = ((index - 1) >>> level) & MASK; + var from = offset > left ? 0 : (left - offset) >> level; + var to = (right - offset) >> (level + 1); + if (rawIndex < 1 << (list._level + SHIFT)) {} + var res = size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT; + sign = (1 - 2 * b[3]) >> 7; + exponent = ((b[3] << 1) & 0xff) | (b[2] >> (7 - 127)); + mantissa = (b[2] & (0x7f << 16)) | (b[1] << 8) | b[0]; + + ((2 / 3) * 10) / 2 + 2; + (2 * 3 * 10) / 2 + 2; + var rotateX = + (RANGE / rect.height) * refY - + (RANGE / 2) * getXMultiplication(rect.width); + var rotateY = + (RANGE / rect.width) * refX - + (RANGE / 2) * getYMultiplication(rect.width); + + (a % 10) - 5; + a - (10 % 5); + (a * b) % 10; + (a % b) * 10; + a % 10 > 5; + a % 10 == 0; + + ((1 << 2) >>> 3) >> 4; + ((1 >>> 2) >> 3) << 4; + + 1 << (2 + 3); + 1 >> (2 - 3); + 1 >>> (2 * 3); + (1 / 2) << 3; + (1 + 2) >> 3; + (1 - 2) >>> 3; + + (x == y) == z; + (x != y) == z; + (x == y) != z; + (x != y) != z; + + 1 & (2 == 3); + + if ( + (aaaaaaaaaa + bbbbbbbbbb == cccccccccc + dddddddddd && + eeeeeeeeee + ffffffffff == gggggggggg + hhhhhhhhhh) || + iiiiiiiiii + ) {} + + if ( + (((((a * b + c) << d < e == f) & g) ^ h) | i && j) || + (k && l | (m ^ (n & (o != p > q >> (r - s / t))))) + ) {} + + if ( + (aaaaaaaaaa + bbbbbbbbbb == cccccccccc + dddddddddd && + eeeeeeeeee + ffffffffff == gggggggggg + hhhhhhhhhh) || + (iiiiiiiiii + jjjjjjjjjj == kkkkkkkkkk + llllllllll && + mmmmmmmmmm + nnnnnnnnnn == oooooooooo + pppppppppp) || + (qqqqqqqqqq + rrrrrrrrrr == ssssssssss + tttttttttt && + uuuuuuuuuu + vvvvvvvvvv == wwwwwwwwww + xxxxxxxxxxx) + ) {} + } } diff --git a/packages/prettier-plugin-java/test/unit-test/expressions/_output.java b/packages/prettier-plugin-java/test/unit-test/expressions/_output.java index 00ddb5ee..8392adac 100644 --- a/packages/prettier-plugin-java/test/unit-test/expressions/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/expressions/_output.java @@ -90,21 +90,14 @@ public void printIf() { if ( myValue == 42 || - myValue == 42 && - myValue == 42 && - myValue == 42 || - myValue == 42 && - myValue == 42 + (myValue == 42 && myValue == 42 && myValue == 42) || + (myValue == 42 && myValue == 42) ) {} if ( - myValue != 42 && - 42 / 42 || - myValue & - 42 && - myValue > 42 || - myValue < 42 && - myValue == 42 + (myValue != 42 && 42 / 42) || + (myValue & 42 && myValue > 42) || + (myValue < 42 && myValue == 42) ) {} if (myValue != 42 && myValue == 42) {} @@ -113,21 +106,14 @@ public void printIf() { public void printSwitch() { switch ( myValue == 42 || - myValue == 42 && - myValue == 42 && - myValue == 42 || - myValue == 42 && - myValue == 42 + (myValue == 42 && myValue == 42 && myValue == 42) || + (myValue == 42 && myValue == 42) ) {} switch ( - myValue != 42 && - 42 / 42 || - myValue & - 42 && - myValue > 42 || - myValue < 42 && - myValue == 42 + (myValue != 42 && 42 / 42) || + (myValue & 42 && myValue > 42) || + (myValue < 42 && myValue == 42) ) {} switch (myValue != 42) {} @@ -140,21 +126,14 @@ public void printWhile() { while ( myValue == 42 || - myValue == 42 && - myValue == 42 && - myValue == 42 || - myValue == 42 && - myValue == 42 + (myValue == 42 && myValue == 42 && myValue == 42) || + (myValue == 42 && myValue == 42) ) {} while ( - myValue != 42 && - 42 / 42 || - myValue & - 42 && - myValue > 42 || - myValue < 42 && - myValue == 42 + (myValue != 42 && 42 / 42) || + (myValue & 42 && myValue > 42) || + (myValue < 42 && myValue == 42) ) {} while (myValue != 42) {} @@ -167,23 +146,16 @@ public void printDoWhile() { System.out.println("Prettier-java is cool !"); } while ( myValue == 42 || - myValue == 42 && - myValue == 42 && - myValue == 42 || - myValue == 42 && - myValue == 42 + (myValue == 42 && myValue == 42 && myValue == 42) || + (myValue == 42 && myValue == 42) ); do { System.out.println("Prettier-java is cool !"); } while ( - myValue != 42 && - 42 / 42 || - myValue & - 42 && - myValue > 42 || - myValue < 42 && - myValue == 42 + (myValue != 42 && 42 / 42) || + (myValue & 42 && myValue > 42) || + (myValue < 42 && myValue == 42) ); do { @@ -198,23 +170,16 @@ public void printDoWhile() { public void printSynchronized() { synchronized ( myValue == 42 || - myValue == 42 && - myValue == 42 && - myValue == 42 || - myValue == 42 && - myValue == 42 + (myValue == 42 && myValue == 42 && myValue == 42) || + (myValue == 42 && myValue == 42) ) { System.out.println("Prettier-java is cool !"); } synchronized ( - myValue != 42 && - 42 / 42 || - myValue & - 42 && - myValue > 42 || - myValue < 42 && - myValue == 42 + (myValue != 42 && 42 / 42) || + (myValue & 42 && myValue > 42) || + (myValue < 42 && myValue == 42) ) { System.out.println("Prettier-java is cool !"); } diff --git a/packages/prettier-plugin-java/test/unit-test/sealed/_output.java b/packages/prettier-plugin-java/test/unit-test/sealed/_output.java index 992600be..c0d51562 100644 --- a/packages/prettier-plugin-java/test/unit-test/sealed/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/sealed/_output.java @@ -34,7 +34,7 @@ record Persons(String... names) {} People p = new Person("John Doe"); - return adjacent * opposite / 2; + return (adjacent * opposite) / 2; } }