prettier-plugin-java 2.7.3 → 2.7.5

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

@@ -104,7 +104,7 @@ declare const _default: {
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
     resourceSpecification(path: import("prettier").AstPath<import("java-parser").ResourceSpecificationCstNode & {
         comments?: import("../comments.js").JavaComment[];
-    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "()";
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "()";
     resourceList(path: import("prettier").AstPath<import("java-parser").ResourceListCstNode & {
         comments?: import("../comments.js").JavaComment[];
     }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];

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

@@ -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;
     },
@@ -318,9 +319,9 @@ export default {
         }
         return join(" ", blocks);
     },
-    resourceSpecification(path, print, options) {
+    resourceSpecification(path, print) {
         const resources = [call(path, print, "resourceList")];
-        if (options.trailingComma !== "none") {
+        if (path.node.children.Semicolon) {
             resources.push(ifBreak(";"));
         }
         return indentInParentheses(resources);

package/dist/printers/expressions.d.ts

@@ -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,5 +1,5 @@
 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";
+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 { removeLines, willBreak } = utils;
 export default {
@@ -62,16 +62,23 @@ export default {
     conciseLambdaParameter: printSingle,
     lambdaBody: printSingle,
     conditionalExpression(path, print) {
+        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 expressions = map(path, print, "expression");
+        const contents = indent(join(line, [
+            binaryExpression,
+            ["? ", expressions[0]],
+            [": ", expressions[1]]
+        ]));
+        const isNestedTernary = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) ===
+            "conditionalExpression";
+        return isNestedTernary ? contents : group(contents);
     },
     binaryExpression(path, print, options) {
+        var _a, _b;
         const { children } = path.node;
         const operands = flatMap(path, print, definedKeys(children, [
             "expression",
@@ -101,8 +108,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 +191,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 +351,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 +462,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 +507,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 +577,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 +584,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 +594,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[];
@@ -30,7 +30,7 @@ export declare function printList<T extends JavaNonTerminal, P extends IterPrope
 export declare function printClassPermits(path: AstPath<ClassPermitsCstNode | InterfacePermitsCstNode>, print: JavaPrintFn): builders.Group;
 export declare function printClassType(path: AstPath<JavaNonTerminal & {
     children: ClassTypeCtx;
-}>, print: JavaPrintFn): builders.Doc[][];
+}>, print: JavaPrintFn): builders.Doc[];
 export declare function isBinaryExpression(expression: ExpressionCstNode): boolean;
 export declare function findBaseIndent(lines: string[]): number;
 export declare function isEmptyStatement(statement: StatementCstNode): boolean;

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]) {
@@ -181,23 +181,29 @@ export function printClassPermits(path, print) {
     ]);
 }
 export function printClassType(path, print) {
-    return flatMap(path, childPath => {
-        const { node, isLast } = childPath;
-        const child = [print(childPath)];
-        if (isTerminal(node)) {
-            if (!isLast) {
-                child.push(".");
+    const { children } = path.node;
+    return definedKeys(children, ["annotation", "Identifier", "typeArguments"])
+        .flatMap(child => children[child].map((node, index) => ({
+        child,
+        index,
+        startOffset: parser.locStart(node)
+    })))
+        .sort((a, b) => a.startOffset - b.startOffset)
+        .flatMap(({ child, index: childIndex }, index, array) => {
+        const node = children[child][childIndex];
+        const next = array.at(index + 1);
+        const nextNode = next && children[next.child][next.index];
+        const docs = [path.call(print, "children", child, childIndex)];
+        if (nextNode) {
+            if (isNonTerminal(node)) {
+                docs.push(node.name === "annotation" ? " " : ".");
+            }
+            else if (isTerminal(nextNode) || nextNode.name === "annotation") {
+                docs.push(".");
             }
         }
-        else if (node.name === "annotation") {
-            child.push(" ");
-        }
-        return child;
-    }, definedKeys(path.node.children, [
-        "annotation",
-        "Identifier",
-        "typeArguments"
-    ]));
+        return docs;
+    });
 }
 export function isBinaryExpression(expression) {
     var _a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.7.3",
+  "version": "2.7.5",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": {
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "ec18b2fe1bcecd353d32cdcba7483cd0f88cb8a2"
+  "gitHead": "dfec507ed2e6d4cea3b2b8d012b2bcc3c626ba23"
 }