prettier-plugin-java 2.7.4 → 2.7.6

package/dist/comments.d.ts

@@ -12,6 +12,6 @@ export type JavaComment = IToken & {
     trailing: boolean;
     printed: boolean;
     enclosingNode?: JavaNonTerminal;
-    precedingNode?: JavaNonTerminal;
-    followingNode?: JavaNonTerminal;
+    precedingNode?: JavaNode;
+    followingNode?: JavaNode;
 };

package/dist/comments.js

@@ -67,6 +67,7 @@ export function canAttachComment(node) {
 export function handleLineComment(commentNode, _, options) {
     return [
         handleBinaryExpressionComments,
+        handleConditionalExpressionComments,
         handleFqnOrRefTypeComments,
         handleIfStatementComments,
         handleJumpStatementComments,
@@ -84,9 +85,7 @@ export function handleRemainingComment(commentNode) {
 }
 function handleBinaryExpressionComments(commentNode, options) {
     const { enclosingNode, precedingNode, followingNode } = commentNode;
-    if (enclosingNode &&
-        isNonTerminal(enclosingNode) &&
-        enclosingNode.name === "binaryExpression") {
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "binaryExpression") {
         if (isBinaryOperator(followingNode)) {
             if (options.experimentalOperatorPosition === "start") {
                 util.addLeadingComment(followingNode, commentNode);
@@ -104,12 +103,23 @@ function handleBinaryExpressionComments(commentNode, options) {
     }
     return false;
 }
+function handleConditionalExpressionComments(commentNode) {
+    const { startLine, endLine, enclosingNode, precedingNode, followingNode } = commentNode;
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "conditionalExpression" &&
+        precedingNode &&
+        followingNode &&
+        isNonTerminal(precedingNode) &&
+        isNonTerminal(followingNode) &&
+        precedingNode.location.endLine < startLine &&
+        endLine < followingNode.location.startLine) {
+        util.addLeadingComment(followingNode, commentNode);
+        return true;
+    }
+    return false;
+}
 function handleFqnOrRefTypeComments(commentNode) {
     const { enclosingNode, followingNode } = commentNode;
-    if (enclosingNode &&
-        isNonTerminal(enclosingNode) &&
-        enclosingNode.name === "fqnOrRefType" &&
-        followingNode) {
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "fqnOrRefType" && followingNode) {
         util.addLeadingComment(followingNode, commentNode);
         return true;
     }
@@ -117,9 +127,7 @@ function handleFqnOrRefTypeComments(commentNode) {
 }
 function handleIfStatementComments(commentNode) {
     const { enclosingNode, precedingNode } = commentNode;
-    if (enclosingNode &&
-        isNonTerminal(enclosingNode) &&
-        enclosingNode.name === "ifStatement" &&
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "ifStatement" &&
         precedingNode &&
         isNonTerminal(precedingNode) &&
         precedingNode.name === "statement") {
@@ -133,7 +141,6 @@ function handleJumpStatementComments(commentNode) {
     if (enclosingNode &&
         !precedingNode &&
         !followingNode &&
-        isNonTerminal(enclosingNode) &&
         ["breakStatement", "continueStatement", "returnStatement"].includes(enclosingNode.name)) {
         util.addTrailingComment(enclosingNode, commentNode);
         return true;
@@ -142,10 +149,8 @@ function handleJumpStatementComments(commentNode) {
 }
 function handleLabeledStatementComments(commentNode) {
     const { enclosingNode, precedingNode } = commentNode;
-    if (enclosingNode &&
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "labeledStatement" &&
         precedingNode &&
-        isNonTerminal(enclosingNode) &&
-        enclosingNode.name === "labeledStatement" &&
         isTerminal(precedingNode) &&
         precedingNode.tokenType.name === "Identifier") {
         util.addLeadingComment(precedingNode, commentNode);
@@ -155,9 +160,7 @@ function handleLabeledStatementComments(commentNode) {
 }
 function handleMethodDeclaratorComments(commentNode) {
     const { enclosingNode } = commentNode;
-    if (enclosingNode &&
-        isNonTerminal(enclosingNode) &&
-        enclosingNode.name === "methodDeclarator" &&
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.name) === "methodDeclarator" &&
         !enclosingNode.children.receiverParameter &&
         !enclosingNode.children.formalParameterList &&
         enclosingNode.children.LBrace[0].startOffset < commentNode.startOffset &&
@@ -171,7 +174,6 @@ function handleNameComments(commentNode) {
     const { enclosingNode, precedingNode } = commentNode;
     if (enclosingNode &&
         precedingNode &&
-        isNonTerminal(enclosingNode) &&
         isTerminal(precedingNode) &&
         precedingNode.tokenType.name === "Identifier" &&
         [

package/dist/printers/arrays.d.ts

@@ -1,7 +1,7 @@
 declare const _default: {
     arrayInitializer(path: import("prettier").AstPath<import("java-parser").ArrayInitializerCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): import("prettier/doc.js").builders.Group | "{}";
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): import("prettier/doc.js").builders.Group | (string | import("prettier/doc.js").builders.Indent | import("prettier/doc.js").builders.Hardline)[] | "{}";
     variableInitializerList(path: import("prettier").AstPath<import("java-parser").VariableInitializerListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): import("prettier/doc.js").builders.Doc[];

package/dist/printers/blocks-and-statements.d.ts

@@ -3,7 +3,7 @@ import { printSingle } from "./helpers.js";
 declare const _default: {
     block(path: import("prettier").AstPath<import("java-parser").BlockCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     blockStatements(path: import("prettier").AstPath<import("java-parser").BlockStatementsCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
@@ -36,7 +36,7 @@ declare const _default: {
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
     switchBlock(path: import("prettier").AstPath<import("java-parser").SwitchBlockCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     switchBlockStatementGroup(path: import("prettier").AstPath<import("java-parser").SwitchBlockStatementGroupCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];

package/dist/printers/blocks-and-statements.js

@@ -1,5 +1,5 @@
 import { builders } from "prettier/doc";
-import { call, definedKeys, indentInParentheses, isBinaryExpression, isEmptyStatement, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printDanglingComments, printSingle, printWithModifiers } from "./helpers.js";
+import { call, definedKeys, hasLeadingComments, indentInParentheses, isBinaryExpression, isEmptyStatement, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printDanglingComments, printSingle, printWithModifiers } from "./helpers.js";
 const { group, hardline, ifBreak, indent, join, line, softline } = builders;
 export default {
     block(path, print) {
@@ -50,10 +50,11 @@ export default {
         var _a;
         const { children } = path.node;
         const hasEmptyStatement = isEmptyStatement(children.statement[0]);
+        const statements = map(path, print, "statement");
         const statement = [
             "if ",
             indentInParentheses(call(path, print, "expression")),
-            hasEmptyStatement ? ";" : [" ", call(path, print, "statement", 0)]
+            hasEmptyStatement ? ";" : [" ", statements[0]]
         ];
         if (children.Else) {
             const danglingComments = printDanglingComments(path);
@@ -67,7 +68,7 @@ export default {
                 statement.push(elseHasBlock ? " " : hardline);
             }
             const elseHasEmptyStatement = isEmptyStatement(children.statement[1]);
-            statement.push("else", elseHasEmptyStatement ? ";" : [" ", call(path, print, "statement", 1)]);
+            statement.push("else", elseHasEmptyStatement ? ";" : [" ", statements[1]]);
         }
         return statement;
     },
@@ -147,11 +148,14 @@ export default {
             "expression",
             "throwStatement"
         ]);
-        const parts = [
-            call(path, print, "switchLabel"),
-            " -> ",
-            call(path, print, bodyKey)
-        ];
+        const body = call(path, print, bodyKey);
+        const parts = [call(path, print, "switchLabel"), " ->"];
+        if (bodyKey !== "block" && hasLeadingComments(children[bodyKey][0])) {
+            parts.push(indent([hardline, body]));
+        }
+        else {
+            parts.push(" ", body);
+        }
         if (children.Semicolon) {
             parts.push(";");
         }

package/dist/printers/classes.d.ts

@@ -28,7 +28,7 @@ declare const _default: {
     }>, print: JavaPrintFn): builders.Group;
     classBody(path: AstPath<ClassBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     classBodyDeclaration: typeof printSingle;
     classMemberDeclaration(path: AstPath<import("java-parser").ClassMemberDeclarationCstNode & {
         comments?: import("../comments.js").JavaComment[];
@@ -106,7 +106,7 @@ declare const _default: {
     simpleTypeName: typeof printSingle;
     constructorBody(path: AstPath<import("java-parser").ConstructorBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     explicitConstructorInvocation: typeof printSingle;
     unqualifiedExplicitConstructorInvocation(path: AstPath<import("java-parser").UnqualifiedExplicitConstructorInvocationCstNode & {
         comments?: import("../comments.js").JavaComment[];
@@ -119,7 +119,7 @@ declare const _default: {
     }>, print: JavaPrintFn): builders.Doc[];
     enumBody(path: AstPath<import("java-parser").EnumBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     enumConstantList(path: AstPath<import("java-parser").EnumConstantListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: JavaPrintFn): builders.Doc[];
@@ -148,7 +148,7 @@ declare const _default: {
     recordComponentModifier: typeof printSingle;
     recordBody(path: AstPath<import("java-parser").RecordBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     recordBodyDeclaration: typeof printSingle;
     compactConstructorDeclaration(path: AstPath<import("java-parser").CompactConstructorDeclarationCstNode & {
         comments?: import("../comments.js").JavaComment[];

package/dist/printers/expressions.d.ts

@@ -30,7 +30,7 @@ declare const _default: {
     lambdaBody: typeof printSingle;
     conditionalExpression(path: AstPath<import("java-parser").ConditionalExpressionCstNode & {
         comments?: JavaComment[];
-    }>, print: JavaPrintFn): builders.Doc;
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
     binaryExpression(path: AstPath<import("java-parser").BinaryExpressionCstNode & {
         comments?: JavaComment[];
     }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
@@ -112,10 +112,10 @@ declare const _default: {
     template: typeof printSingle;
     stringTemplate(path: AstPath<StringTemplateCstNode & {
         comments?: JavaComment[];
-    }>, print: JavaPrintFn): (builders.Group | builders.Doc[])[];
+    }>, print: JavaPrintFn): builders.Indent;
     textBlockTemplate(path: AstPath<TextBlockTemplateCstNode & {
         comments?: JavaComment[];
-    }>, print: JavaPrintFn): (builders.Group | builders.Doc[])[];
+    }>, print: JavaPrintFn): builders.Indent;
     embeddedExpression: typeof printSingle;
     pattern: typeof printSingle;
     typePattern: typeof printSingle;

package/dist/printers/expressions.js

@@ -1,6 +1,6 @@
 import { builders, utils } from "prettier/doc";
-import { call, definedKeys, each, findBaseIndent, flatMap, indentInParentheses, isBinaryExpression, isNonTerminal, isTerminal, map, onlyDefinedKey, printDanglingComments, printList, printName, printSingle } from "./helpers.js";
-const { breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
+import { call, definedKeys, each, findBaseIndent, flatMap, hasLeadingComments, indentInParentheses, isBinaryExpression, 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 {
     expression: printSingle,
@@ -61,17 +61,29 @@ export default {
     lambdaParameterType: printSingle,
     conciseLambdaParameter: printSingle,
     lambdaBody: printSingle,
-    conditionalExpression(path, print) {
+    conditionalExpression(path, print, options) {
+        var _a;
         const binaryExpression = call(path, print, "binaryExpression");
-        return path.node.children.QuestionMark
-            ? group(indent(join(line, [
-                binaryExpression,
-                ["? ", call(path, print, "expression", 0)],
-                [": ", call(path, print, "expression", 1)]
-            ])))
-            : binaryExpression;
+        if (!path.node.children.QuestionMark) {
+            return binaryExpression;
+        }
+        const [consequent, alternate] = map(path, print, "expression");
+        const parts = [binaryExpression];
+        const part = [
+            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));
     },
     binaryExpression(path, print, options) {
+        var _a, _b;
         const { children } = path.node;
         const operands = flatMap(path, print, definedKeys(children, [
             "expression",
@@ -101,8 +113,11 @@ export default {
         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";
         return binary(operands, operators, {
             hasNonAssignmentOperators,
+            isInList,
             isRoot: true,
             operatorPosition: options.experimentalOperatorPosition
         });
@@ -181,7 +196,8 @@ export default {
                     : suffix);
             }
         }, "primarySuffix");
-        return group(canBreakForCallExpressions || willBreak(suffixes)
+        const hasSuffixComments = children.primarySuffix.some(suffix => hasLeadingComments(suffix));
+        return group(canBreakForCallExpressions || hasSuffixComments
             ? [prefix, indent(suffixes)]
             : [prefix, ...suffixes]);
     },
@@ -340,7 +356,7 @@ export default {
             return allArgsExpandable;
         }
         const headArgs = args.slice(0, -1);
-        const huggedLastArg = call(path, argPath => print(argPath, { hug: true }), "expression", args.length - 1);
+        const huggedLastArg = path.call(argPath => print(argPath, { hug: true }), "children", "expression", args.length - 1);
         const lastArgExpanded = join(", ", [
             ...headArgs,
             group(huggedLastArg, { shouldBreak: true })
@@ -451,7 +467,7 @@ export default {
         ];
     }
 };
-function binary(operands, operators, { hasNonAssignmentOperators = false, isRoot = false, operatorPosition }) {
+function binary(operands, operators, { hasNonAssignmentOperators = false, isInList = false, isRoot = false, operatorPosition }) {
     let levelOperator;
     let levelPrecedence;
     let level = [];
@@ -496,7 +512,10 @@ function binary(operands, operators, { hasNonAssignmentOperators = false, isRoot
         }
     }
     level.push(operands.shift());
-    if (!levelOperator || !isAssignmentOperator(levelOperator)) {
+    if (!levelOperator ||
+        (!isInList &&
+            !isAssignmentOperator(levelOperator) &&
+            levelOperator !== "instanceof")) {
         return group(level);
     }
     if (!isRoot || hasNonAssignmentOperators) {
@@ -563,7 +582,6 @@ function isCapitalizedIdentifier(fqnOrRefType) {
     return /^\p{Uppercase_Letter}/u.test(nextToLastIdentifier !== null && nextToLastIdentifier !== void 0 ? nextToLastIdentifier : "");
 }
 function printTemplate(path, print, beginKey, midKey, endKey) {
-    const { children } = path.node;
     const begin = call(path, ({ node }) => node.image, beginKey);
     const mids = map(path, ({ node }) => node.image, midKey);
     const end = call(path, ({ node }) => node.image, endKey);
@@ -571,7 +589,7 @@ function printTemplate(path, print, beginKey, midKey, endKey) {
     const baseIndent = findBaseIndent(lines);
     const prefix = "\n" + " ".repeat(baseIndent);
     const parts = [begin, ...mids, end].map(image => join(hardline, image.split(prefix)));
-    return [
+    return indent([
         parts[0],
         ...map(path, (expressionPath, index) => {
             const expression = group([
@@ -581,5 +599,5 @@ function printTemplate(path, print, beginKey, midKey, endKey) {
             return index === 0 ? expression : [parts[index], expression];
         }, "embeddedExpression"),
         parts.at(-1)
-    ];
+    ]);
 }

package/dist/printers/helpers.d.ts

@@ -6,7 +6,7 @@ export declare function onlyDefinedKey<T extends Record<string, any>, K extends
 export declare function definedKeys<T extends Record<string, any>, K extends Key<T> & string>(obj: T, options?: K[]): K[];
 export declare function printWithModifiers<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, modifierChild: P, contents: Doc, noTypeAnnotations?: boolean): builders.Doc[];
 export declare function hasDeclarationAnnotations(modifiers: ModifierNode[]): boolean;
-export declare function call<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P, index?: number): U;
+export declare function call<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U;
 export declare function each<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, void>, child: P): void;
 export declare function map<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U[];
 export declare function flatMap<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, children: P[]): U[];
@@ -15,12 +15,12 @@ export declare function lineStartWithComments(node: JavaNonTerminal): number;
 export declare function lineEndWithComments(node: JavaNonTerminal): number;
 export declare function printDanglingComments(path: AstPath<JavaNonTerminal>): builders.Doc[];
 export declare function printComment(node: JavaTerminal): string | builders.Doc[];
-export declare function hasLeadingComments(node: JavaNode): boolean | undefined;
+export declare function hasLeadingComments(node: JavaNode): boolean;
 export declare function indentInParentheses(contents: Doc, opts?: {
     shouldBreak?: boolean;
 }): builders.Group | "()";
-export declare function printArrayInitializer<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, options: JavaParserOptions, child: P): builders.Group | "{}";
-export declare function printBlock(path: AstPath<JavaNonTerminal>, contents: Doc[]): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+export declare function printArrayInitializer<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, options: JavaParserOptions, child: P): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
+export declare function printBlock(path: AstPath<JavaNonTerminal>, contents: Doc[]): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
 export declare function printName(path: AstPath<JavaNonTerminal & {
     children: {
         Identifier: IToken[];

package/dist/printers/helpers.js

@@ -71,8 +71,8 @@ export function hasDeclarationAnnotations(modifiers) {
     }
     return hasAnnotation && !hasNonAnnotation;
 }
-export function call(path, callback, child, index = 0) {
-    return path.map(callback, "children", child)[index];
+export function call(path, callback, child) {
+    return path.map(callback, "children", child)[0];
 }
 export function each(path, callback, child) {
     if (path.node.children[child]) {
@@ -135,8 +135,8 @@ export function printComment(node) {
         : image;
 }
 export function hasLeadingComments(node) {
-    var _a;
-    return (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading);
+    var _a, _b;
+    return (_b = (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading)) !== null && _b !== void 0 ? _b : false;
 }
 export function indentInParentheses(contents, opts) {
     return !Array.isArray(contents) || contents.length
@@ -144,14 +144,16 @@ export function indentInParentheses(contents, opts) {
         : "()";
 }
 export function printArrayInitializer(path, print, options, child) {
-    const list = [];
-    if (child && child in path.node.children) {
-        list.push(call(path, print, child));
-        if (options.trailingComma !== "none") {
-            list.push(ifBreak(","));
-        }
+    if (!(child && child in path.node.children)) {
+        const danglingComments = printDanglingComments(path);
+        return danglingComments.length
+            ? ["{", indent([hardline, ...danglingComments]), hardline, "}"]
+            : "{}";
+    }
+    const list = [call(path, print, child)];
+    if (options.trailingComma !== "none") {
+        list.push(ifBreak(","));
     }
-    list.push(...printDanglingComments(path));
     return list.length ? group(["{", indent([line, ...list]), line, "}"]) : "{}";
 }
 export function printBlock(path, contents) {
@@ -193,7 +195,7 @@ export function printClassType(path, print) {
         const node = children[child][childIndex];
         const next = array.at(index + 1);
         const nextNode = next && children[next.child][next.index];
-        const docs = [call(path, print, child, childIndex)];
+        const docs = [path.call(print, "children", child, childIndex)];
         if (nextNode) {
             if (isNonTerminal(node)) {
                 docs.push(node.name === "annotation" ? " " : ".");

package/dist/printers/interfaces.d.ts

@@ -14,7 +14,7 @@ declare const _default: {
     interfacePermits: typeof printClassPermits;
     interfaceBody(path: import("prettier").AstPath<import("java-parser").InterfaceBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     interfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceMemberDeclarationCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
@@ -31,7 +31,7 @@ declare const _default: {
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
     annotationInterfaceBody(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceBodyCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     annotationInterfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceMemberDeclarationCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
@@ -54,7 +54,7 @@ declare const _default: {
     elementValue: typeof printSingle;
     elementValueArrayInitializer(path: import("prettier").AstPath<import("java-parser").ElementValueArrayInitializerCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}";
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | (string | builders.Indent | builders.Hardline)[] | "{}";
     elementValueList(path: import("prettier").AstPath<import("java-parser").ElementValueListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Group;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": {
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "306a608c6ff6aee2010120ffb47a8c8a13fe7ef1"
+  "gitHead": "9f2ba5e304a7e2d744fa20f1f3617cc4a4651f88"
 }