prettier-plugin-java 2.7.7 → 2.8.1

package/LICENSE

@@ -1,5 +1,5 @@
 
-    Copyright 2018-2025 the original author or authors from the JHipster project
+    Copyright 2018-2026 the original author or authors from the JHipster project
 
                                  Apache License
                            Version 2.0, January 2004

package/dist/comments.d.ts

@@ -1,8 +1,8 @@
 import type { IToken } from "java-parser";
 import { type AstPath } from "prettier";
 import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
-export declare function determineFormatterOffOnRanges(cst: JavaNonTerminal): void;
-export declare function isFullyBetweenFormatterOffOn(path: AstPath<JavaNode>): boolean;
+export declare function determinePrettierIgnoreRanges(cst: JavaNonTerminal): void;
+export declare function isFullyBetweenPrettierIgnore(path: AstPath<JavaNode>): boolean;
 export declare function canAttachComment(node: JavaNode): boolean;
 export declare function handleLineComment(commentNode: JavaComment, _: string, options: JavaParserOptions): boolean;
 export declare function handleRemainingComment(commentNode: JavaComment): boolean;

package/dist/comments.js

@@ -1,35 +1,35 @@
 import { util } from "prettier";
 import parser from "./parser.js";
 import { isEmptyStatement, isNonTerminal, isTerminal } from "./printers/helpers.js";
-const formatterOffOnRangesByCst = new WeakMap();
-export function determineFormatterOffOnRanges(cst) {
+const prettierIgnoreRangesByCst = new WeakMap();
+export function determinePrettierIgnoreRanges(cst) {
     const { comments } = cst;
     if (!comments) {
         return;
     }
     const ranges = comments
-        .filter(({ image }) => /^(\/\/\s*@formatter:(off|on)\s*|\/\*\s*@formatter:(off|on)\s*\*\/)$/.test(image))
+        .filter(({ image }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(image))
         .reduce((ranges, { image, startOffset }) => {
         const previous = ranges.at(-1);
-        if (image.endsWith("off")) {
-            if ((previous === null || previous === void 0 ? void 0 : previous.on) !== Infinity) {
-                ranges.push({ off: startOffset, on: Infinity });
+        if (image.includes("start") || image.includes("off")) {
+            if ((previous === null || previous === void 0 ? void 0 : previous.end) !== Infinity) {
+                ranges.push({ start: startOffset, end: Infinity });
             }
         }
-        else if ((previous === null || previous === void 0 ? void 0 : previous.on) === Infinity) {
-            previous.on = startOffset;
+        else if ((previous === null || previous === void 0 ? void 0 : previous.end) === Infinity) {
+            previous.end = startOffset;
         }
         return ranges;
     }, new Array());
-    formatterOffOnRangesByCst.set(cst, ranges);
+    prettierIgnoreRangesByCst.set(cst, ranges);
 }
-export function isFullyBetweenFormatterOffOn(path) {
+export function isFullyBetweenPrettierIgnore(path) {
     var _a;
     const { node, root } = path;
     const start = parser.locStart(node);
     const end = parser.locEnd(node);
-    return (((_a = formatterOffOnRangesByCst
-        .get(root)) === null || _a === void 0 ? void 0 : _a.some(range => range.off < start && end < range.on)) === true);
+    return (((_a = prettierIgnoreRangesByCst
+        .get(root)) === null || _a === void 0 ? void 0 : _a.some(range => range.start < start && end < range.end)) === true);
 }
 export function canAttachComment(node) {
     var _a, _b, _c;
@@ -72,7 +72,8 @@ export function handleLineComment(commentNode, _, options) {
         handleIfStatementComments,
         handleJumpStatementComments,
         handleLabeledStatementComments,
-        handleNameComments
+        handleNameComments,
+        handleTryStatementComments
     ].some(fn => fn(commentNode, options));
 }
 export function handleRemainingComment(commentNode) {
@@ -192,6 +193,33 @@ function handleNameComments(commentNode) {
     }
     return false;
 }
+function handleTryStatementComments(commentNode) {
+    var _a, _b;
+    const { enclosingNode, followingNode } = commentNode;
+    if (enclosingNode &&
+        ["catches", "tryStatement"].includes(enclosingNode.name) &&
+        followingNode &&
+        isNonTerminal(followingNode)) {
+        const block = (_a = (followingNode.name === "catches"
+            ? followingNode.children.catchClause[0]
+            : followingNode.name === "catchClause" ||
+                followingNode.name === "finally"
+                ? followingNode
+                : null)) === null || _a === void 0 ? void 0 : _a.children.block[0];
+        if (!block) {
+            return false;
+        }
+        const blockStatement = (_b = block.children.blockStatements) === null || _b === void 0 ? void 0 : _b[0].children.blockStatement[0];
+        if (blockStatement) {
+            util.addLeadingComment(blockStatement, commentNode);
+        }
+        else {
+            util.addDanglingComment(block, commentNode, undefined);
+        }
+        return true;
+    }
+    return false;
+}
 function isBinaryOperator(node) {
     var _a;
     return (node !== undefined &&

package/dist/parser.js

@@ -1,5 +1,5 @@
 import { parse } from "java-parser";
-import { determineFormatterOffOnRanges } from "./comments.js";
+import { determinePrettierIgnoreRanges } from "./comments.js";
 import { isTerminal } from "./printers/helpers.js";
 export default {
     parse(text, options) {
@@ -8,7 +8,7 @@ export default {
         (_a = cst.comments) === null || _a === void 0 ? void 0 : _a.forEach(comment => {
             comment.value = comment.image;
         });
-        determineFormatterOffOnRanges(cst);
+        determinePrettierIgnoreRanges(cst);
         return cst;
     },
     astFormat: "java",

package/dist/printer.js

@@ -1,4 +1,4 @@
-import { canAttachComment, handleLineComment, handleRemainingComment, isFullyBetweenFormatterOffOn } from "./comments.js";
+import { canAttachComment, handleLineComment, handleRemainingComment, isFullyBetweenPrettierIgnore } from "./comments.js";
 import { isNonTerminal, isTerminal, printComment } from "./printers/helpers.js";
 import { printerForNodeType } from "./printers/index.js";
 export default {
@@ -11,7 +11,7 @@ export default {
         var _a;
         const { node } = path;
         return (((_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ image }) => /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(image))) === true ||
-            (canAttachComment(node) && isFullyBetweenFormatterOffOn(path)));
+            (canAttachComment(node) && isFullyBetweenPrettierIgnore(path)));
     },
     canAttachComment,
     isBlockComment(node) {

package/dist/printers/classes.d.ts

@@ -12,7 +12,7 @@ declare const _default: {
     classModifier: typeof printSingle;
     typeParameters(path: AstPath<import("java-parser").TypeParametersCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group;
+    }>, print: JavaPrintFn): (string | builders.Indent | builders.Softline)[];
     typeParameterList(path: AstPath<import("java-parser").TypeParameterListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: JavaPrintFn): builders.Doc[];
@@ -25,7 +25,7 @@ declare const _default: {
     classPermits: typeof printClassPermits;
     interfaceTypeList(path: AstPath<import("java-parser").InterfaceTypeListCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group;
+    }>, print: JavaPrintFn): builders.Doc[];
     classBody(path: AstPath<ClassBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
@@ -135,7 +135,7 @@ declare const _default: {
     }>, print: JavaPrintFn): builders.Doc[];
     recordHeader(path: AstPath<import("java-parser").RecordHeaderCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group | "()";
+    }>, print: JavaPrintFn): builders.Group | (string | builders.Indent | builders.Softline)[] | "()";
     recordComponentList(path: AstPath<import("java-parser").RecordComponentListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: JavaPrintFn): builders.Doc[];

package/dist/printers/classes.js

@@ -1,5 +1,5 @@
 import { builders } from "prettier/doc";
-import { call, each, hasDeclarationAnnotations, hasLeadingComments, indentInParentheses, isBinaryExpression, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printClassPermits, printClassType, printDanglingComments, printList, printSingle, printWithModifiers } from "./helpers.js";
+import { call, definedKeys, each, hasDeclarationAnnotations, hasLeadingComments, hasNonAssignmentOperators, indentInParentheses, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printClassPermits, printClassType, printDanglingComments, printList, printSingle, printWithModifiers } from "./helpers.js";
 const { group, hardline, indent, indentIfBreak, join, line, softline } = builders;
 export default {
     classDeclaration(path, print) {
@@ -12,30 +12,45 @@ export default {
         return printWithModifiers(path, print, "classModifier", declaration, true);
     },
     normalClassDeclaration(path, print) {
-        const { classExtends, classImplements, classPermits, typeParameters } = path.node.children;
-        const header = ["class ", call(path, print, "typeIdentifier")];
-        if (typeParameters) {
-            header.push(call(path, print, "typeParameters"));
-        }
-        if (classExtends) {
-            header.push(indent([line, call(path, print, "classExtends")]));
-        }
-        if (classImplements) {
-            header.push(indent([line, call(path, print, "classImplements")]));
+        const { children } = path.node;
+        const definedClauses = definedKeys(children, [
+            "classExtends",
+            "classImplements",
+            "classPermits"
+        ]);
+        const hasMultipleClauses = definedClauses.length > 1;
+        const hasTypeParameters = children.typeParameters !== undefined;
+        const parts = ["class ", call(path, print, "typeIdentifier")];
+        if (hasTypeParameters) {
+            const typeParameters = call(path, print, "typeParameters");
+            parts.push(hasMultipleClauses ? group(indent(typeParameters)) : typeParameters);
+        }
+        if (definedClauses.length) {
+            const separator = hasTypeParameters && !hasMultipleClauses ? " " : line;
+            const clauses = definedClauses.flatMap(clause => [
+                separator,
+                call(path, print, clause)
+            ]);
+            const hasBody = children.classBody[0].children.classBodyDeclaration !== undefined;
+            const clauseGroup = [
+                hasTypeParameters && !hasMultipleClauses ? clauses : indent(clauses),
+                hasBody ? separator : " "
+            ];
+            parts.push(hasMultipleClauses ? clauseGroup : group(clauseGroup));
         }
-        if (classPermits) {
-            header.push(indent([line, call(path, print, "classPermits")]));
+        else {
+            parts.push(" ");
         }
-        return [group(header), " ", call(path, print, "classBody")];
+        return [group(parts), call(path, print, "classBody")];
     },
     classModifier: printSingle,
     typeParameters(path, print) {
-        return group([
+        return [
             "<",
             indent([softline, call(path, print, "typeParameterList")]),
             softline,
             ">"
-        ]);
+        ];
     },
     typeParameterList(path, print) {
         return printList(path, print, "typeParameter");
@@ -51,7 +66,7 @@ export default {
     },
     classPermits: printClassPermits,
     interfaceTypeList(path, print) {
-        return group(printList(path, print, "interfaceType"));
+        return printList(path, print, "interfaceType");
     },
     classBody(path, print) {
         return printBlock(path, printClassBodyDeclarations(path, print));
@@ -84,18 +99,18 @@ export default {
             : join(", ", declarators);
     },
     variableDeclarator(path, print) {
-        var _a, _b;
+        var _a, _b, _c;
         const { children } = path.node;
         const variableInitializer = (_a = children.variableInitializer) === null || _a === void 0 ? void 0 : _a[0];
         const declaratorId = call(path, print, "variableDeclaratorId");
         if (!variableInitializer) {
             return declaratorId;
         }
-        const expression = (_b = variableInitializer.children.expression) === null || _b === void 0 ? void 0 : _b[0];
+        const binaryExpression = (_c = (_b = variableInitializer.children.expression) === null || _b === void 0 ? void 0 : _b[0].children.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children.binaryExpression[0];
         const declarator = [declaratorId, " ", call(path, print, "Equals")];
         const initializer = call(path, print, "variableInitializer");
         if (hasLeadingComments(variableInitializer) ||
-            (expression && isBinaryExpression(expression))) {
+            (binaryExpression && hasNonAssignmentOperators(binaryExpression))) {
             declarator.push(group(indent([line, initializer])));
         }
         else {
@@ -140,7 +155,7 @@ export default {
         const { typeParameters, annotation, throws } = path.node.children;
         const header = [];
         if (typeParameters) {
-            header.push(call(path, print, "typeParameters"));
+            header.push(group(call(path, print, "typeParameters")));
         }
         if (annotation) {
             header.push(join(line, map(path, print, "annotation")));
@@ -237,7 +252,7 @@ export default {
             ? indentInParentheses(join([",", line], parameters))
             : "()");
         return children.typeParameters
-            ? [call(path, print, "typeParameters"), " ", ...header]
+            ? [group(call(path, print, "typeParameters")), " ", ...header]
             : header;
     },
     simpleTypeName: printSingle,
@@ -286,11 +301,18 @@ export default {
         return invocation;
     },
     enumDeclaration(path, print) {
-        const header = ["enum", call(path, print, "typeIdentifier")];
-        if (path.node.children.classImplements) {
-            header.push(call(path, print, "classImplements"));
+        const { children } = path.node;
+        const parts = ["enum ", call(path, print, "typeIdentifier")];
+        if (children.classImplements) {
+            const body = children.enumBody[0].children;
+            const hasBody = body.enumBodyDeclarations !== undefined ||
+                body.enumConstantList !== undefined;
+            parts.push(indent([line, call(path, print, "classImplements")]), hasBody ? line : " ");
         }
-        return join(" ", [...header, call(path, print, "enumBody")]);
+        else {
+            parts.push(" ");
+        }
+        return [group(parts), call(path, print, "enumBody")];
     },
     enumBody(path, print, options) {
         var _a;
@@ -337,19 +359,36 @@ export default {
     },
     recordDeclaration(path, print) {
         const { children } = path.node;
-        const header = ["record ", call(path, print, "typeIdentifier")];
+        const parts = ["record ", call(path, print, "typeIdentifier")];
         if (children.typeParameters) {
-            header.push(call(path, print, "typeParameters"));
+            parts.push(group(call(path, print, "typeParameters")));
         }
-        header.push(call(path, print, "recordHeader"));
+        parts.push(call(path, print, "recordHeader"));
         if (children.classImplements) {
-            header.push(" ", call(path, print, "classImplements"));
+            const hasComponents = children.recordHeader[0].children.recordComponentList !== undefined;
+            const hasBody = children.recordBody[0].children.recordBodyDeclaration !== undefined;
+            const classImplements = [
+                hasComponents ? " " : line,
+                call(path, print, "classImplements")
+            ];
+            parts.push(group([
+                hasComponents ? classImplements : indent(classImplements),
+                hasBody ? line : " "
+            ]));
+        }
+        else {
+            parts.push(" ");
         }
-        return [group(header), " ", call(path, print, "recordBody")];
+        return [group(parts), call(path, print, "recordBody")];
     },
     recordHeader(path, print) {
         return path.node.children.recordComponentList
-            ? indentInParentheses(call(path, print, "recordComponentList"))
+            ? [
+                "(",
+                indent([softline, call(path, print, "recordComponentList")]),
+                softline,
+                ")"
+            ]
             : indentInParentheses(printDanglingComments(path), { shouldBreak: true });
     },
     recordComponentList(path, print) {

package/dist/printers/expressions.d.ts

@@ -1,4 +1,4 @@
-import type { StringTemplateCstNode, TextBlockTemplateCstNode } from "java-parser";
+import type { BinaryExpressionCstNode, PrimaryCstNode, StringTemplateCstNode, TextBlockTemplateCstNode } from "java-parser";
 import type { AstPath } from "prettier";
 import { builders } from "prettier/doc";
 import type { JavaComment } from "../comments.js";
@@ -31,7 +31,7 @@ declare const _default: {
     conditionalExpression(path: AstPath<import("java-parser").ConditionalExpressionCstNode & {
         comments?: JavaComment[];
     }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
-    binaryExpression(path: AstPath<import("java-parser").BinaryExpressionCstNode & {
+    binaryExpression(path: AstPath<BinaryExpressionCstNode & {
         comments?: JavaComment[];
     }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
     unaryExpression(path: AstPath<import("java-parser").UnaryExpressionCstNode & {
@@ -40,7 +40,7 @@ declare const _default: {
     unaryExpressionNotPlusMinus(path: AstPath<import("java-parser").UnaryExpressionNotPlusMinusCstNode & {
         comments?: JavaComment[];
     }>, print: JavaPrintFn): builders.Doc[];
-    primary(path: AstPath<import("java-parser").PrimaryCstNode & {
+    primary(path: AstPath<PrimaryCstNode & {
         comments?: JavaComment[];
     }>, print: JavaPrintFn): builders.Doc;
     primaryPrefix: typeof printSingle;
@@ -61,7 +61,7 @@ declare const _default: {
     }>, print: JavaPrintFn): builders.Doc;
     parenthesisExpression(path: AstPath<import("java-parser").ParenthesisExpressionCstNode & {
         comments?: JavaComment[];
-    }>, print: JavaPrintFn): builders.Group | builders.Doc[] | "()";
+    }>, print: JavaPrintFn): builders.Group | "()";
     castExpression: typeof printSingle;
     primitiveCastExpression(path: AstPath<import("java-parser").PrimitiveCastExpressionCstNode & {
         comments?: JavaComment[];

package/dist/printers/expressions.js

@@ -1,5 +1,5 @@
 import { builders, utils } from "prettier/doc";
-import { call, definedKeys, each, findBaseIndent, flatMap, hasLeadingComments, indentInParentheses, isBinaryExpression, isNonTerminal, isTerminal, map, onlyDefinedKey, printDanglingComments, printList, printName, printSingle } from "./helpers.js";
+import { call, definedKeys, each, findBaseIndent, flatMap, hasAssignmentOperators, hasLeadingComments, hasNonAssignmentOperators, indentInParentheses, isNonTerminal, isTerminal, map, onlyDefinedKey, printDanglingComments, printList, printName, printSingle } from "./helpers.js";
 const { align, breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
 const { removeLines, willBreak } = utils;
 export default {
@@ -64,26 +64,32 @@ export default {
     conditionalExpression(path, print, options) {
         var _a;
         const binaryExpression = call(path, print, "binaryExpression");
+        const grandparentNodeName = (_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name;
+        const isInParentheses = grandparentNodeName === "parenthesisExpression";
         if (!path.node.children.QuestionMark) {
-            return binaryExpression;
+            return isInParentheses ? binaryExpression : group(binaryExpression);
         }
+        const isInReturn = grandparentNodeName === "returnStatement";
+        const prefix = group(isInReturn ? indent(binaryExpression) : binaryExpression);
         const [consequent, alternate] = map(path, print, "expression");
-        const parts = [binaryExpression];
-        const part = [
+        const suffix = [
             line,
             ["? ", options.useTabs ? indent(consequent) : align(2, consequent)],
             line,
             [": ", options.useTabs ? indent(alternate) : align(2, alternate)]
         ];
-        const isNestedTernary = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) ===
-            "conditionalExpression";
-        parts.push(!isNestedTernary || options.useTabs
-            ? part
-            : align(Math.max(0, options.tabWidth - 2), part));
-        return isNestedTernary ? parts : group(indent(parts));
+        const isNestedTernary = grandparentNodeName === "conditionalExpression";
+        const alignedSuffix = !isNestedTernary || options.useTabs
+            ? suffix
+            : align(Math.max(0, options.tabWidth - 2), suffix);
+        if (isNestedTernary) {
+            return [prefix, alignedSuffix];
+        }
+        const parts = [prefix, indent(alignedSuffix)];
+        return isInParentheses ? parts : group(parts);
     },
     binaryExpression(path, print, options) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const { children } = path.node;
         const operands = flatMap(path, print, definedKeys(children, [
             "expression",
@@ -110,13 +116,12 @@ export default {
             "Instanceof",
             "shiftOperator"
         ]));
-        const hasNonAssignmentOperators = (operators.length > 0 && !children.AssignmentOperator) ||
-            (children.expression !== undefined &&
-                isBinaryExpression(children.expression[0]));
         const isInList = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) === "elementValue" ||
             ((_b = path.getNode(6)) === null || _b === void 0 ? void 0 : _b.name) === "argumentList";
+        const binaryExpression = (_d = (_c = children.expression) === null || _c === void 0 ? void 0 : _c[0].children.conditionalExpression) === null || _d === void 0 ? void 0 : _d[0].children.binaryExpression[0];
         return binary(operands, operators, {
-            hasNonAssignmentOperators,
+            hasNonAssignmentOperators: (operators.length > 0 && !children.AssignmentOperator) ||
+                (binaryExpression && hasNonAssignmentOperators(binaryExpression)),
             isInList,
             isRoot: true,
             operatorPosition: options.experimentalOperatorPosition
@@ -265,20 +270,36 @@ export default {
             : keyword;
     },
     parenthesisExpression(path, print) {
-        var _a;
         const expression = call(path, print, "expression");
-        const ancestorName = (_a = path.getNode(14)) === null || _a === void 0 ? void 0 : _a.name;
-        const binaryExpression = path.getNode(8);
+        const primaryAncestor = path.getNode(4);
+        const binaryExpressionAncestor = path.getNode(8);
+        const outerAncestor = path.getNode(14);
         const { conditionalExpression, lambdaExpression } = path.node.children.expression[0].children;
         const hasLambda = lambdaExpression !== undefined;
         const hasTernary = (conditionalExpression === null || conditionalExpression === void 0 ? void 0 : conditionalExpression[0].children.QuestionMark) !== undefined;
-        return ancestorName &&
-            ["guard", "returnStatement"].includes(ancestorName) &&
-            binaryExpression &&
-            binaryExpression.name === "binaryExpression" &&
-            Object.keys(binaryExpression.children).length === 1
-            ? indentInParentheses(expression)
-            : ["(", hasLambda || hasTernary ? expression : indent(expression), ")"];
+        const hasSuffix = (primaryAncestor === null || primaryAncestor === void 0 ? void 0 : primaryAncestor.children.primarySuffix) !== undefined;
+        const isAssignment = ((outerAncestor === null || outerAncestor === void 0 ? void 0 : outerAncestor.name) === "binaryExpression" &&
+            hasAssignmentOperators(outerAncestor)) ||
+            (outerAncestor === null || outerAncestor === void 0 ? void 0 : outerAncestor.name) === "variableInitializer";
+        if (!hasLambda && hasSuffix && (!hasTernary || isAssignment)) {
+            return indentInParentheses(hasTernary ? group(expression) : expression);
+        }
+        else if (binaryExpressionAncestor &&
+            Object.keys(binaryExpressionAncestor.children).length === 1 &&
+            outerAncestor &&
+            ["guard", "returnStatement"].includes(outerAncestor.name)) {
+            return indentInParentheses(group(expression));
+        }
+        else if (hasTernary && hasSuffix && !isAssignment) {
+            return group(["(", expression, softline, ")"]);
+        }
+        else {
+            return group([
+                "(",
+                hasLambda || hasTernary ? expression : indent(expression),
+                ")"
+            ]);
+        }
     },
     castExpression: printSingle,
     primitiveCastExpression(path, print) {
@@ -510,8 +531,8 @@ function binary(operands, operators, { hasNonAssignmentOperators = false, isInLi
             const content = binary(operands, operators, { operatorPosition });
             operands.unshift(levelOperator !== undefined &&
                 needsParentheses(nextOperator, levelOperator)
-                ? ["(", indent(content), ")"]
-                : content);
+                ? ["(", group(indent(content)), ")"]
+                : group(content));
         }
     }
     level.push(operands.shift());
@@ -519,17 +540,17 @@ function binary(operands, operators, { hasNonAssignmentOperators = false, isInLi
         (!isInList &&
             !isAssignmentOperator(levelOperator) &&
             levelOperator !== "instanceof")) {
-        return group(level);
+        return level;
     }
     if (!isRoot || hasNonAssignmentOperators) {
-        return group(indent(level));
+        return indent(level);
     }
     const groupId = Symbol("assignment");
-    return group([
+    return [
         level[0],
         group(indent(level[1]), { id: groupId }),
         indentIfBreak(level[2], { groupId })
-    ]);
+    ];
 }
 const precedencesByOperator = new Map([
     ["||"],

package/dist/printers/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { AnnotationCstNode, ClassPermitsCstNode, ClassTypeCtx, CstElement, CstNode, ExpressionCstNode, InterfacePermitsCstNode, IToken, StatementCstNode } from "java-parser";
+import type { AnnotationCstNode, BinaryExpressionCstNode, ClassPermitsCstNode, ClassTypeCtx, CstElement, CstNode, ExpressionCstNode, InterfacePermitsCstNode, IToken, StatementCstNode } from "java-parser";
 import type { AstPath, Doc, ParserOptions } from "prettier";
 import { builders } from "prettier/doc";
 import type { JavaComment } from "../comments.js";
@@ -32,6 +32,8 @@ export declare function printClassType(path: AstPath<JavaNonTerminal & {
     children: ClassTypeCtx;
 }>, print: JavaPrintFn): builders.Doc[];
 export declare function isBinaryExpression(expression: ExpressionCstNode): boolean;
+export declare function hasAssignmentOperators(binaryExpression: BinaryExpressionCstNode): boolean;
+export declare function hasNonAssignmentOperators(binaryExpression: BinaryExpressionCstNode): boolean;
 export declare function findBaseIndent(lines: string[]): number;
 export declare function isEmptyStatement(statement: StatementCstNode): boolean;
 export declare function isNonTerminal(node: CstElement): node is JavaNonTerminal;

package/dist/printers/helpers.js

@@ -157,18 +157,52 @@ export function printArrayInitializer(path, print, options, child) {
     return list.length ? group(["{", indent([line, ...list]), line, "}"]) : "{}";
 }
 export function printBlock(path, contents) {
-    if (!contents.length) {
-        const danglingComments = printDanglingComments(path);
-        return danglingComments.length
-            ? ["{", indent([hardline, ...danglingComments]), hardline, "}"]
-            : "{}";
+    if (contents.length) {
+        return group([
+            "{",
+            indent([hardline, ...join(hardline, contents)]),
+            hardline,
+            "}"
+        ]);
     }
-    return group([
-        "{",
-        indent([hardline, ...join(hardline, contents)]),
-        hardline,
-        "}"
-    ]);
+    const danglingComments = printDanglingComments(path);
+    if (danglingComments.length) {
+        return ["{", indent([hardline, ...danglingComments]), hardline, "}"];
+    }
+    const parent = path.grandparent;
+    const grandparent = path.getNode(4);
+    const greatGrandparent = path.getNode(6);
+    return ((grandparent === null || grandparent === void 0 ? void 0 : grandparent.name) === "catches" &&
+        grandparent.children.catchClause.length === 1 &&
+        ((greatGrandparent === null || greatGrandparent === void 0 ? void 0 : greatGrandparent.name) === "tryStatement" ||
+            (greatGrandparent === null || greatGrandparent === void 0 ? void 0 : greatGrandparent.name) === "tryWithResourcesStatement") &&
+        !greatGrandparent.children.finally) ||
+        (greatGrandparent &&
+            [
+                "basicForStatement",
+                "doStatement",
+                "enhancedForStatement",
+                "whileStatement"
+            ].includes(greatGrandparent.name)) ||
+        [
+            "annotationInterfaceBody",
+            "classBody",
+            "constructorBody",
+            "enumBody",
+            "interfaceBody",
+            "moduleDeclaration",
+            "recordBody"
+        ].includes(path.node.name) ||
+        (parent &&
+            [
+                "instanceInitializer",
+                "lambdaBody",
+                "methodBody",
+                "staticInitializer",
+                "synchronizedStatement"
+            ].includes(parent.name))
+        ? "{}"
+        : ["{", hardline, "}"];
 }
 export function printName(path, print) {
     return join(".", map(path, print, "Identifier"));
@@ -177,10 +211,7 @@ export function printList(path, print, child) {
     return join([",", line], map(path, print, child));
 }
 export function printClassPermits(path, print) {
-    return group([
-        "permits",
-        indent([line, group(printList(path, print, "typeName"))])
-    ]);
+    return group(["permits", indent([line, printList(path, print, "typeName")])]);
 }
 export function printClassType(path, print) {
     const { children } = path.node;
@@ -217,12 +248,13 @@ export function isBinaryExpression(expression) {
     if (isTernary) {
         return false;
     }
-    const hasNonAssignmentOperators = Object.values(conditionalExpression.binaryExpression[0].children).some(child => {
-        var _a;
-        return isTerminal(child[0]) &&
-            !((_a = child[0].tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(category => category.name === "AssignmentOperator"));
-    });
-    return hasNonAssignmentOperators;
+    return hasNonAssignmentOperators(conditionalExpression.binaryExpression[0]);
+}
+export function hasAssignmentOperators(binaryExpression) {
+    return binaryExpression.children.AssignmentOperator !== undefined;
+}
+export function hasNonAssignmentOperators(binaryExpression) {
+    return Object.keys(binaryExpression.children).some(name => ["BinaryOperator", "Instanceof", "shiftOperator"].includes(name));
 }
 export function findBaseIndent(lines) {
     return lines.length

package/dist/printers/interfaces.js

@@ -1,5 +1,5 @@
 import { builders } from "prettier/doc";
-import { call, each, hasDeclarationAnnotations, indentInParentheses, lineEndWithComments, lineStartWithComments, onlyDefinedKey, printArrayInitializer, printBlock, printClassPermits, printList, printSingle, printWithModifiers } from "./helpers.js";
+import { call, definedKeys, each, hasDeclarationAnnotations, indentInParentheses, lineEndWithComments, lineStartWithComments, onlyDefinedKey, printArrayInitializer, printBlock, printClassPermits, printList, printSingle, printWithModifiers } from "./helpers.js";
 const { group, hardline, indent, join, line } = builders;
 export default {
     interfaceDeclaration(path, print) {
@@ -10,18 +10,36 @@ export default {
         return printWithModifiers(path, print, "interfaceModifier", call(path, print, declarationKey), true);
     },
     normalInterfaceDeclaration(path, print) {
-        const { interfaceExtends, interfacePermits, typeParameters } = path.node.children;
-        const header = ["interface ", call(path, print, "typeIdentifier")];
-        if (typeParameters) {
-            header.push(call(path, print, "typeParameters"));
+        const { children } = path.node;
+        const definedClauses = definedKeys(children, [
+            "interfaceExtends",
+            "interfacePermits"
+        ]);
+        const hasMultipleClauses = definedClauses.length > 1;
+        const hasTypeParameters = children.typeParameters !== undefined;
+        const parts = ["interface ", call(path, print, "typeIdentifier")];
+        if (hasTypeParameters) {
+            const typeParameters = call(path, print, "typeParameters");
+            parts.push(hasMultipleClauses ? group(indent(typeParameters)) : typeParameters);
         }
-        if (interfaceExtends) {
-            header.push(indent([line, call(path, print, "interfaceExtends")]));
+        if (definedClauses.length) {
+            const separator = hasTypeParameters && !hasMultipleClauses ? " " : line;
+            const clauses = definedClauses.flatMap(clause => [
+                separator,
+                call(path, print, clause)
+            ]);
+            const hasBody = children.interfaceBody[0].children.interfaceMemberDeclaration !==
+                undefined;
+            const clauseGroup = [
+                hasTypeParameters && !hasMultipleClauses ? clauses : indent(clauses),
+                hasBody ? separator : " "
+            ];
+            parts.push(hasMultipleClauses ? clauseGroup : group(clauseGroup));
         }
-        if (interfacePermits) {
-            header.push(indent([line, call(path, print, "interfacePermits")]));
+        else {
+            parts.push(" ");
         }
-        return [group(header), " ", call(path, print, "interfaceBody")];
+        return [group(parts), call(path, print, "interfaceBody")];
     },
     interfaceModifier: printSingle,
     interfaceExtends(path, print) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.7.7",
+  "version": "2.8.1",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": {
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "dc42509e151ec718e2cb9812669906035a63a09b"
+  "gitHead": "f403f75d5f308e388ac5d27550a177bb0bd6bef4"
 }