prettier-plugin-java 2.7.5 → 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) {
@@ -148,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;

package/dist/printers/expressions.js

@@ -1,6 +1,6 @@
 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";
-const { breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
+const { align, breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
 const { removeLines, willBreak } = utils;
 export default {
     expression: printSingle,
@@ -61,21 +61,26 @@ export default {
     lambdaParameterType: printSingle,
     conciseLambdaParameter: printSingle,
     lambdaBody: printSingle,
-    conditionalExpression(path, print) {
+    conditionalExpression(path, print, options) {
         var _a;
         const binaryExpression = call(path, print, "binaryExpression");
         if (!path.node.children.QuestionMark) {
             return binaryExpression;
         }
-        const expressions = map(path, print, "expression");
-        const contents = indent(join(line, [
-            binaryExpression,
-            ["? ", expressions[0]],
-            [": ", expressions[1]]
-        ]));
+        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";
-        return isNestedTernary ? contents : group(contents);
+        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;

package/dist/printers/helpers.d.ts

@@ -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

@@ -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) {

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.5",
+  "version": "2.7.6",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": {
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "dfec507ed2e6d4cea3b2b8d012b2bcc3c626ba23"
+  "gitHead": "9f2ba5e304a7e2d744fa20f1f3617cc4a4651f88"
 }