prettier-plugin-java 2.6.8 → 2.7.0

package/dist/printers/expressions.js

@@ -1,591 +1,585 @@
-import forEach from "lodash/forEach.js";
 import { builders, utils } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { isAnnotationCstNode } from "../types/utils.js";
-import { printArgumentListWithBraces } from "../utils/index.js";
-import { hasLeadingComments } from "./comments/comments-utils.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { handleCommentsBinaryExpression, handleCommentsParameters } from "./comments/handle-comments.js";
-import { concat, dedent, group, indent, indentIfBreak } from "./prettier-builder.js";
-import { binary, findDeepElementInPartsArray, getOperators, isExplicitLambdaParameter, isUniqueMethodInvocation, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortAnnotationIdentifier, sortNodes, sortTokens } from "./printer-utils.js";
-const { breakParent, conditionalGroup, ifBreak, label, line, lineSuffixBoundary, softline } = builders;
+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;
 const { removeLines, willBreak } = utils;
-export class ExpressionsPrettierVisitor extends BaseCstPrettierPrinter {
-    expression(ctx, params) {
-        const expression = this.visitSingle(ctx, params);
-        return (params === null || params === void 0 ? void 0 : params.hug) && expression.label !== undefined
-            ? label(expression.label, expression)
-            : expression;
-    }
-    lambdaExpression(ctx, params) {
-        const lambdaParameters = group(this.visit(ctx.lambdaParameters));
-        const lambdaBody = this.visit(ctx.lambdaBody);
-        const isLambdaBodyABlock = ctx.lambdaBody[0].children.block !== undefined;
-        const suffix = [
-            " ",
-            ctx.Arrow[0],
-            ...(isLambdaBodyABlock
-                ? [" ", lambdaBody]
-                : [group([indent([line, lambdaBody]), (params === null || params === void 0 ? void 0 : params.hug) ? softline : ""])])
-        ];
-        if (params === null || params === void 0 ? void 0 : params.hug) {
-            return willBreak(lambdaParameters)
-                ? label({ huggable: false }, concat([lambdaParameters, ...suffix]))
-                : concat([removeLines(lambdaParameters), ...suffix]);
-        }
-        return concat([lambdaParameters, ...suffix]);
-    }
-    lambdaParameters(ctx) {
-        if (ctx.lambdaParametersWithBraces) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    lambdaParametersWithBraces(ctx) {
-        var _a, _b, _c, _d, _e, _f;
-        const lambdaParameters = (_f = (_c = (_b = (_a = ctx.lambdaParameterList) === null || _a === void 0 ? void 0 : _a[0].children.normalLambdaParameterList) === null || _b === void 0 ? void 0 : _b[0].children.normalLambdaParameter) !== null && _c !== void 0 ? _c : (_e = (_d = ctx.lambdaParameterList) === null || _d === void 0 ? void 0 : _d[0].children.conciseLambdaParameterList) === null || _e === void 0 ? void 0 : _e[0].children.conciseLambdaParameter) !== null && _f !== void 0 ? _f : [];
-        handleCommentsParameters(ctx.LBrace[0], lambdaParameters, ctx.RBrace[0]);
-        const lambdaParameterList = this.visit(ctx.lambdaParameterList);
-        if (findDeepElementInPartsArray(lambdaParameterList, ",")) {
-            return concat([
-                ctx.LBrace[0],
-                indent([softline, lambdaParameterList]),
-                softline,
-                ctx.RBrace[0]
-            ]);
+export default {
+    expression: printSingle,
+    lambdaExpression(path, print, _, args = {}) {
+        var _a;
+        const hug = (_a = args.hug) !== null && _a !== void 0 ? _a : false;
+        const parameters = call(path, print, "lambdaParameters");
+        const expression = [hug ? removeLines(parameters) : parameters, " ->"];
+        const lambdaExpression = path.node.children.lambdaBody[0].children.expression;
+        const body = call(path, print, "lambdaBody");
+        if (lambdaExpression) {
+            const suffix = indent([line, body]);
+            expression.push(group(hug ? [suffix, softline] : suffix));
         }
-        // removing braces when only no comments attached
-        if ((ctx.LBrace &&
-            ctx.RBrace &&
-            (!lambdaParameterList || isExplicitLambdaParameter(ctx))) ||
-            ctx.LBrace[0].leadingComments ||
-            ctx.LBrace[0].trailingComments ||
-            ctx.RBrace[0].leadingComments ||
-            ctx.RBrace[0].trailingComments) {
-            return rejectAndConcat([
-                ctx.LBrace[0],
-                lambdaParameterList,
-                ctx.RBrace[0]
-            ]);
+        else {
+            expression.push(" ", body);
         }
-        return lambdaParameterList;
-    }
-    lambdaParameterList(ctx) {
-        return this.visitSingle(ctx);
-    }
-    conciseLambdaParameterList(ctx) {
+        return expression;
+    },
+    lambdaParameters(path, print, options) {
+        const parameters = printSingle(path, print);
+        return !path.node.children.lambdaParametersWithBraces &&
+            options.arrowParens === "always"
+            ? ["(", parameters, ")"]
+            : parameters;
+    },
+    lambdaParametersWithBraces(path, print, options) {
         var _a;
-        const conciseLambdaParameters = this.mapVisit(ctx.conciseLambdaParameter);
-        const commas = (_a = ctx.Comma) === null || _a === void 0 ? void 0 : _a.map(comma => concat([comma, line]));
-        return rejectAndJoinSeps(commas, conciseLambdaParameters);
-    }
-    normalLambdaParameterList(ctx) {
-        var _a;
-        const normalLambdaParameter = this.mapVisit(ctx.normalLambdaParameter);
-        const commas = (_a = ctx.Comma) === null || _a === void 0 ? void 0 : _a.map(comma => concat([comma, line]));
-        return rejectAndJoinSeps(commas, normalLambdaParameter);
-    }
-    normalLambdaParameter(ctx) {
-        return this.visitSingle(ctx);
-    }
-    regularLambdaParameter(ctx) {
-        const variableModifier = this.mapVisit(ctx.variableModifier);
-        const lambdaParameterType = this.visit(ctx.lambdaParameterType);
-        const variableDeclaratorId = this.visit(ctx.variableDeclaratorId);
-        return rejectAndJoin(" ", [
-            rejectAndJoin(" ", variableModifier),
-            lambdaParameterType,
-            variableDeclaratorId
-        ]);
-    }
-    lambdaParameterType(ctx) {
-        if (ctx.unannType) {
-            return this.visitSingle(ctx);
+        const { lambdaParameterList } = path.node.children;
+        if (!lambdaParameterList) {
+            return "()";
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    conciseLambdaParameter(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    lambdaBody(ctx) {
-        return this.visitSingle(ctx);
-    }
-    conditionalExpression(ctx, params) {
-        const binaryExpression = this.visit(ctx.binaryExpression, params);
-        if (ctx.QuestionMark) {
-            const expression1 = this.visit(ctx.expression[0]);
-            const expression2 = this.visit(ctx.expression[1]);
-            return indent(group(rejectAndConcat([
-                rejectAndJoin(line, [
-                    binaryExpression,
-                    rejectAndJoin(" ", [ctx.QuestionMark[0], expression1]),
-                    rejectAndJoin(" ", [ctx.Colon[0], expression2])
-                ])
-            ])));
+        const { conciseLambdaParameterList, normalLambdaParameterList } = lambdaParameterList[0].children;
+        const parameterCount = ((_a = conciseLambdaParameterList === null || conciseLambdaParameterList === void 0 ? void 0 : conciseLambdaParameterList[0].children.conciseLambdaParameter) !== null && _a !== void 0 ? _a : normalLambdaParameterList === null || normalLambdaParameterList === void 0 ? void 0 : normalLambdaParameterList[0].children.normalLambdaParameter).length;
+        const parameters = call(path, print, "lambdaParameterList");
+        if (parameterCount > 1) {
+            return indentInParentheses(parameters);
         }
-        return binaryExpression;
-    }
-    binaryExpression(ctx, params) {
-        var _a, _b, _c, _d;
-        handleCommentsBinaryExpression(ctx);
-        const sortedNodes = sortNodes([
-            ctx.pattern,
-            ctx.referenceType,
-            ctx.expression,
-            ctx.unaryExpression
+        return conciseLambdaParameterList && options.arrowParens === "avoid"
+            ? parameters
+            : ["(", parameters, ")"];
+    },
+    lambdaParameterList: printSingle,
+    conciseLambdaParameterList(path, print) {
+        return printList(path, print, "conciseLambdaParameter");
+    },
+    normalLambdaParameterList(path, print) {
+        return printList(path, print, "normalLambdaParameter");
+    },
+    normalLambdaParameter: printSingle,
+    regularLambdaParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "lambdaParameterType"),
+            call(path, print, "variableDeclaratorId")
         ]);
-        const tokens = sortTokens(getOperators(ctx));
-        const hasTokens = tokens.length > 0;
-        const nodeParams = sortedNodes.length === 1 ? params : undefined;
-        const nodes = [];
-        for (let i = 0; i < sortedNodes.length; i++) {
-            const node = this.visit(sortedNodes[i], nodeParams);
-            const isAssignment = ((_b = (_a = tokens[i]) === null || _a === void 0 ? void 0 : _a.tokenType.CATEGORIES) === null || _b === void 0 ? void 0 : _b.find(({ name }) => name === "AssignmentOperator")) !== undefined;
-            if (!isAssignment) {
-                nodes.push(node);
-                continue;
+    },
+    lambdaParameterType: printSingle,
+    conciseLambdaParameter: printSingle,
+    lambdaBody: printSingle,
+    conditionalExpression(path, print) {
+        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;
+    },
+    binaryExpression(path, print, options) {
+        const { children } = path.node;
+        const operands = flatMap(path, print, definedKeys(children, [
+            "expression",
+            "pattern",
+            "referenceType",
+            "unaryExpression"
+        ]));
+        const operators = flatMap(path, operatorPath => {
+            const { node } = operatorPath;
+            let image;
+            if (isTerminal(node)) {
+                image = node.image;
+            }
+            else if (node.children.Less) {
+                image = "<<";
             }
-            const [equals] = tokens.splice(i, 1);
-            const expression = sortedNodes[++i];
-            const nextNode = this.visit(expression);
-            const conditionalExpression = (_c = expression.children.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children;
-            const binaryExpression = (_d = conditionalExpression === null || conditionalExpression === void 0 ? void 0 : conditionalExpression.binaryExpression) === null || _d === void 0 ? void 0 : _d[0].children;
-            const breakAfterOperator = (conditionalExpression === null || conditionalExpression === void 0 ? void 0 : conditionalExpression.QuestionMark) === undefined &&
-                binaryExpression !== undefined &&
-                getOperators(binaryExpression).length > 0;
-            if (breakAfterOperator) {
-                nodes.push(concat([node, " ", equals, group(indent([line, nextNode]))]));
-                continue;
+            else {
+                image = node.children.Greater.length === 2 ? ">>" : ">>>";
             }
-            const groupId = Symbol("assignment");
-            nodes.push(concat([
-                node,
-                " ",
-                equals,
-                indent(group(line, { id: groupId })),
-                indentIfBreak(nextNode, { groupId })
-            ]));
+            return { image, doc: print(operatorPath) };
+        }, definedKeys(children, [
+            "AssignmentOperator",
+            "BinaryOperator",
+            "Instanceof",
+            "shiftOperator"
+        ]));
+        const hasNonAssignmentOperators = (operators.length > 0 && !children.AssignmentOperator) ||
+            (children.expression !== undefined &&
+                isBinaryExpression(children.expression[0]));
+        return binary(operands, operators, {
+            hasNonAssignmentOperators,
+            isRoot: true,
+            operatorPosition: options.experimentalOperatorPosition
+        });
+    },
+    unaryExpression(path, print) {
+        return [
+            ...map(path, print, "UnaryPrefixOperator"),
+            call(path, print, "primary"),
+            ...map(path, print, "UnarySuffixOperator")
+        ];
+    },
+    unaryExpressionNotPlusMinus(path, print) {
+        const { children } = path.node;
+        const expression = [];
+        if (children.UnaryPrefixOperatorNotPlusMinus) {
+            expression.push(...map(path, print, "UnaryPrefixOperatorNotPlusMinus"));
         }
-        const content = binary(nodes, tokens, true);
-        return hasTokens && (params === null || params === void 0 ? void 0 : params.addParenthesisToWrapStatement)
-            ? group(concat([
-                ifBreak("("),
-                indent(concat([softline, content])),
-                softline,
-                ifBreak(")")
-            ]))
-            : content;
-    }
-    unaryExpression(ctx, params) {
-        const unaryPrefixOperator = ctx.UnaryPrefixOperator
-            ? ctx.UnaryPrefixOperator
-            : [];
-        const primary = this.visit(ctx.primary, params);
-        const unarySuffixOperator = ctx.UnarySuffixOperator
-            ? ctx.UnarySuffixOperator
-            : [];
-        return rejectAndConcat([
-            rejectAndConcat(unaryPrefixOperator),
-            primary,
-            rejectAndConcat(unarySuffixOperator)
-        ]);
-    }
-    unaryExpressionNotPlusMinus(ctx) {
-        const unaryPrefixOperatorNotPlusMinus = ctx.UnaryPrefixOperatorNotPlusMinus // changed when moved to TS
-            ? rejectAndJoin(" ", ctx.UnaryPrefixOperatorNotPlusMinus) // changed when moved to TS
-            : "";
-        const primary = this.visit(ctx.primary);
-        const unarySuffixOperator = ctx.UnarySuffixOperator // changed when moved to TS
-            ? rejectAndJoin(" ", ctx.UnarySuffixOperator) // changed when moved to TS
-            : "";
-        return rejectAndJoin(" ", [
-            unaryPrefixOperatorNotPlusMinus,
-            primary,
-            unarySuffixOperator
-        ]);
-    }
-    primary(ctx, params) {
-        var _a, _b, _c, _d;
-        const countMethodInvocation = isUniqueMethodInvocation(ctx.primarySuffix);
-        const newExpression = (_a = ctx.primaryPrefix[0].children.newExpression) === null || _a === void 0 ? void 0 : _a[0].children;
-        const isBreakableNewExpression = countMethodInvocation <= 1 &&
-            this.isBreakableNewExpression(newExpression);
-        const firstMethodInvocation = (_b = ctx.primarySuffix) === null || _b === void 0 ? void 0 : _b.map(suffix => { var _a; return (_a = suffix.children.methodInvocationSuffix) === null || _a === void 0 ? void 0 : _a[0].children; }).find(methodInvocationSuffix => methodInvocationSuffix);
-        const fqnOrRefType = (_c = ctx.primaryPrefix[0].children.fqnOrRefType) === null || _c === void 0 ? void 0 : _c[0].children;
-        const hasFqnRefPart = (fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartRest) !== undefined;
-        const isCapitalizedIdentifier = this.isCapitalizedIdentifier(fqnOrRefType);
-        const shouldBreakBeforeFirstMethodInvocation = countMethodInvocation > 1 && hasFqnRefPart && !isCapitalizedIdentifier;
-        const shouldBreakBeforeMethodInvocations = shouldBreakBeforeFirstMethodInvocation ||
-            countMethodInvocation > 2 ||
-            (countMethodInvocation > 1 && !!newExpression) ||
-            !(firstMethodInvocation === null || firstMethodInvocation === void 0 ? void 0 : firstMethodInvocation.argumentList);
-        const primaryPrefix = this.visit(ctx.primaryPrefix, Object.assign(Object.assign({}, params), { shouldBreakBeforeFirstMethodInvocation }));
-        const suffixes = this.getPrimarySuffixes(ctx, newExpression, isBreakableNewExpression, shouldBreakBeforeMethodInvocations);
-        if (!newExpression && countMethodInvocation === 1) {
-            return group(rejectAndConcat([
-                primaryPrefix,
-                suffixes[0],
-                indent(rejectAndConcat(suffixes.slice(1)))
-            ]));
+        expression.push(call(path, print, "primary"));
+        if (children.UnarySuffixOperator) {
+            expression.push(...map(path, print, "UnarySuffixOperator"));
         }
-        const methodInvocation = (_d = ctx.primarySuffix) === null || _d === void 0 ? void 0 : _d[0].children.methodInvocationSuffix;
-        const isMethodInvocationWithArguments = (methodInvocation === null || methodInvocation === void 0 ? void 0 : methodInvocation[0].children.argumentList) !== undefined;
-        const isUnqualifiedMethodInvocation = methodInvocation !== undefined && !(fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.Dot);
-        return group(rejectAndConcat([
-            primaryPrefix,
-            isCapitalizedIdentifier || isUnqualifiedMethodInvocation
-                ? suffixes.shift()
-                : "",
-            !isBreakableNewExpression &&
-                (shouldBreakBeforeMethodInvocations || !isMethodInvocationWithArguments)
-                ? indent(concat(suffixes))
-                : concat(suffixes)
-        ]));
-    }
-    primaryPrefix(ctx, params) {
-        if (ctx.This || ctx.Void) {
-            return printTokenWithComments(this.getSingle(ctx));
+        return join(" ", expression);
+    },
+    primary(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        if (!children.primarySuffix) {
+            return call(path, print, "primaryPrefix");
         }
-        return this.visitSingle(ctx, params);
-    }
-    primarySuffix(ctx, params) {
-        var _a;
-        if (ctx.Dot) {
-            if (ctx.This) {
-                return rejectAndConcat([ctx.Dot[0], ctx.This[0]]);
+        const methodInvocations = children.primarySuffix
+            .filter(({ children }) => children.methodInvocationSuffix)
+            .map(({ children }) => children.methodInvocationSuffix[0].children);
+        const hasLambdaMethodParameter = methodInvocations.some(({ argumentList }) => argumentList === null || argumentList === void 0 ? void 0 : argumentList[0].children.expression.some(({ children }) => children.lambdaExpression));
+        const prefixIsCallExpression = children.primaryPrefix[0].children.newExpression;
+        const callExpressionCount = methodInvocations.length +
+            (prefixIsCallExpression ? 1 : 0) +
+            children.primarySuffix.filter(({ children }) => children.unqualifiedClassInstanceCreationExpression).length;
+        const fqnOrRefType = (_a = children.primaryPrefix[0].children.fqnOrRefType) === null || _a === void 0 ? void 0 : _a[0].children;
+        const prefixIsMethodInvocation = (fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartRest) !== undefined &&
+            ((_b = children.primarySuffix) === null || _b === void 0 ? void 0 : _b[0].children.methodInvocationSuffix) !== undefined;
+        const prefixIsStaticMethodInvocation = prefixIsMethodInvocation && isCapitalizedIdentifier(fqnOrRefType);
+        const prefixIsInstanceMethodInvocation = prefixIsMethodInvocation && !prefixIsStaticMethodInvocation;
+        const mustBreakForCallExpressions = methodInvocations.length > 2 && hasLambdaMethodParameter;
+        const separator = mustBreakForCallExpressions ? hardline : softline;
+        const prefix = [
+            call(path, prefixPath => print(prefixPath, {
+                lastSeparator: prefixIsStaticMethodInvocation ||
+                    (prefixIsInstanceMethodInvocation && callExpressionCount === 1)
+                    ? ""
+                    : separator
+            }), "primaryPrefix")
+        ];
+        const canBreakForCallExpressions = callExpressionCount > 2 ||
+            (callExpressionCount === 2 && prefixIsInstanceMethodInvocation) ||
+            willBreak(prefix);
+        const suffixes = [];
+        each(path, suffixPath => {
+            const { node, previous } = suffixPath;
+            const suffix = print(suffixPath);
+            if (node.children.Dot) {
+                if ((canBreakForCallExpressions &&
+                    ((!previous && prefixIsCallExpression) ||
+                        (previous === null || previous === void 0 ? void 0 : previous.children.methodInvocationSuffix) ||
+                        (previous === null || previous === void 0 ? void 0 : previous.children.unqualifiedClassInstanceCreationExpression))) ||
+                    (!node.children.templateArgument && willBreak(suffix))) {
+                    suffixes.push(separator);
+                }
+                suffixes.push(suffix);
+            }
+            else if (previous) {
+                suffixes.push(suffix);
             }
-            else if (ctx.Identifier) {
-                const typeArguments = this.visit(ctx.typeArguments);
-                return rejectAndConcat([ctx.Dot[0], typeArguments, ctx.Identifier[0]]);
+            else {
+                prefix.push(prefixIsInstanceMethodInvocation && callExpressionCount >= 2
+                    ? indent(suffix)
+                    : suffix);
             }
-            const suffix = this.visit((_a = ctx.unqualifiedClassInstanceCreationExpression) !== null && _a !== void 0 ? _a : ctx.templateArgument);
-            return rejectAndConcat([ctx.Dot[0], suffix]);
+        }, "primarySuffix");
+        return group(canBreakForCallExpressions || willBreak(suffixes)
+            ? [prefix, indent(suffixes)]
+            : [prefix, ...suffixes]);
+    },
+    primaryPrefix: printSingle,
+    primarySuffix(path, print) {
+        const { children } = path.node;
+        if (!children.Dot) {
+            return printSingle(path, print);
         }
-        return this.visitSingle(ctx, params);
-    }
-    fqnOrRefType(ctx, params) {
-        const fqnOrRefTypePartFirst = this.visit(ctx.fqnOrRefTypePartFirst);
-        const fqnOrRefTypePartRest = this.mapVisit(ctx.fqnOrRefTypePartRest);
-        const dims = this.visit(ctx.dims);
-        const dots = ctx.Dot
-            ? ctx.Dot.map(dot => {
-                if (hasLeadingComments(dot)) {
-                    return concat([softline, dot]);
-                }
-                return dot;
-            })
-            : [];
-        if ((params === null || params === void 0 ? void 0 : params.shouldBreakBeforeFirstMethodInvocation) === true &&
-            ctx.Dot !== undefined) {
-            dots[dots.length - 1] = concat([softline, ctx.Dot[ctx.Dot.length - 1]]);
+        const suffix = ["."];
+        if (children.This) {
+            suffix.push("this");
         }
-        return indent(rejectAndConcat([
-            rejectAndJoinSeps(dots, [
-                fqnOrRefTypePartFirst,
-                ...fqnOrRefTypePartRest
-            ]),
-            dims
-        ]));
-    }
-    fqnOrRefTypePartFirst(ctx) {
-        const annotation = this.mapVisit(ctx.annotation);
-        const fqnOrRefTypeCommon = this.visit(ctx.fqnOrRefTypePartCommon);
-        return rejectAndJoin(" ", [
-            rejectAndJoin(" ", annotation),
-            fqnOrRefTypeCommon
-        ]);
-    }
-    fqnOrRefTypePartRest(ctx) {
-        const annotation = this.mapVisit(ctx.annotation);
-        const fqnOrRefTypeCommon = this.visit(ctx.fqnOrRefTypePartCommon);
-        const typeArguments = this.visit(ctx.typeArguments);
-        return rejectAndJoin(" ", [
-            rejectAndJoin(" ", annotation),
-            rejectAndConcat([typeArguments, fqnOrRefTypeCommon])
-        ]);
-    }
-    fqnOrRefTypePartCommon(ctx) {
-        let keyWord = null;
-        if (ctx.Identifier) {
-            keyWord = ctx.Identifier[0];
+        else if (children.Identifier) {
+            if (children.typeArguments) {
+                suffix.push(call(path, print, "typeArguments"));
+            }
+            suffix.push(call(path, print, "Identifier"));
         }
         else {
-            keyWord = ctx.Super[0];
+            const suffixKey = onlyDefinedKey(children, [
+                "templateArgument",
+                "unqualifiedClassInstanceCreationExpression"
+            ]);
+            suffix.push(call(path, print, suffixKey));
         }
-        const typeArguments = this.visit(ctx.typeArguments);
-        return rejectAndConcat([keyWord, typeArguments]);
-    }
-    parenthesisExpression(ctx, params) {
-        const expression = this.visit(ctx.expression);
-        const separator = (params === null || params === void 0 ? void 0 : params.addParenthesisToWrapStatement) ? softline : "";
-        return putIntoBraces(expression, separator, ctx.LBrace[0], ctx.RBrace[0]);
-    }
-    castExpression(ctx) {
-        return this.visitSingle(ctx);
-    }
-    primitiveCastExpression(ctx) {
-        const primitiveType = this.visit(ctx.primitiveType);
-        const unaryExpression = this.visit(ctx.unaryExpression);
-        return rejectAndJoin(" ", [
-            rejectAndConcat([ctx.LBrace[0], primitiveType, ctx.RBrace[0]]),
-            unaryExpression
-        ]);
-    }
-    referenceTypeCastExpression(ctx) {
-        const referenceType = this.visit(ctx.referenceType);
-        const hasAdditionalBounds = ctx.additionalBound !== undefined;
-        const additionalBounds = rejectAndJoin(line, this.mapVisit(ctx.additionalBound));
-        const expression = ctx.lambdaExpression
-            ? this.visit(ctx.lambdaExpression)
-            : this.visit(ctx.unaryExpressionNotPlusMinus);
-        return rejectAndJoin(" ", [
-            putIntoBraces(rejectAndJoin(line, [referenceType, additionalBounds]), hasAdditionalBounds ? softline : "", ctx.LBrace[0], ctx.RBrace[0]),
-            expression
-        ]);
-    }
-    newExpression(ctx) {
-        return this.visitSingle(ctx);
-    }
-    unqualifiedClassInstanceCreationExpression(ctx) {
-        const typeArguments = this.visit(ctx.typeArguments);
-        const classOrInterfaceTypeToInstantiate = this.visit(ctx.classOrInterfaceTypeToInstantiate);
-        let content = printArgumentListWithBraces.call(this, ctx.argumentList, ctx.RBrace[0], ctx.LBrace[0]);
-        const classBody = this.visit(ctx.classBody);
-        return rejectAndJoin(" ", [
-            ctx.New[0],
-            rejectAndConcat([
-                typeArguments,
-                classOrInterfaceTypeToInstantiate,
-                content
-            ]),
-            classBody
-        ]);
-    }
-    classOrInterfaceTypeToInstantiate(ctx) {
-        const tokens = sortAnnotationIdentifier(ctx.annotation, ctx.Identifier);
-        const segments = [];
-        let currentSegment = [];
-        forEach(tokens, token => {
-            if (isAnnotationCstNode(token)) {
-                currentSegment.push(this.visit([token]));
-            }
-            else {
-                currentSegment.push(token);
-                segments.push(rejectAndJoin(" ", currentSegment));
-                currentSegment = [];
-            }
-        });
-        const typeArgumentsOrDiamond = this.visit(ctx.typeArgumentsOrDiamond);
-        const dots = ctx.Dot ? ctx.Dot : [];
-        return rejectAndConcat([
-            rejectAndJoinSeps(dots, segments),
-            typeArgumentsOrDiamond
+        return suffix;
+    },
+    fqnOrRefType(path, print, _, args) {
+        var _a;
+        const lastSeparator = (_a = args.lastSeparator) !== null && _a !== void 0 ? _a : "";
+        const fqnOrRefType = [
+            call(path, print, "fqnOrRefTypePartFirst"),
+            ...map(path, partPath => {
+                const part = print(partPath);
+                return partPath.isLast
+                    ? [willBreak(part) ? hardline : lastSeparator, part]
+                    : part;
+            }, "fqnOrRefTypePartRest")
+        ];
+        fqnOrRefType.push(indent(fqnOrRefType.pop()));
+        return path.node.children.dims
+            ? [fqnOrRefType, call(path, print, "dims")]
+            : fqnOrRefType;
+    },
+    fqnOrRefTypePartFirst(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "fqnOrRefTypePartCommon")
         ]);
-    }
-    typeArgumentsOrDiamond(ctx) {
-        return this.visitSingle(ctx);
-    }
-    diamond(ctx) {
-        return concat([ctx.Less[0], ctx.Greater[0]]);
-    }
-    methodInvocationSuffix(ctx) {
-        return printArgumentListWithBraces.call(this, ctx.argumentList, ctx.RBrace[0], ctx.LBrace[0]);
-    }
-    argumentList(ctx) {
+    },
+    fqnOrRefTypePartRest(path, print) {
+        const common = call(path, print, "fqnOrRefTypePartCommon");
+        const type = path.node.children.typeArguments
+            ? [call(path, print, "typeArguments"), common]
+            : common;
+        return [".", ...join(" ", [...map(path, print, "annotation"), type])];
+    },
+    fqnOrRefTypePartCommon(path, print) {
+        const { children } = path.node;
+        const keywordKey = onlyDefinedKey(children, ["Identifier", "Super"]);
+        const keyword = call(path, print, keywordKey);
+        return children.typeArguments
+            ? [keyword, call(path, print, "typeArguments")]
+            : keyword;
+    },
+    parenthesisExpression(path, print) {
         var _a;
-        const headArgs = this.mapVisit(ctx.expression.slice(0, -1)).map((expression, index) => concat([expression, ctx.Comma[index], line]));
-        const lastExpression = ctx.expression.at(-1);
-        const lastArg = this.visit(lastExpression);
-        if (this.isArgumentListHuggable(ctx)) {
-            const huggedLastArg = this.visit(lastExpression, { hug: true });
-            const lastArgNotHuggable = typeof huggedLastArg === "object" &&
-                !Array.isArray(huggedLastArg) &&
-                huggedLastArg.type === "label" &&
-                ((_a = huggedLastArg.label) === null || _a === void 0 ? void 0 : _a.huggable) === false;
-            if (lastArgNotHuggable || headArgs.some(willBreak)) {
-                return group([indent([line, ...headArgs, lastArg]), line], {
-                    shouldBreak: true
-                });
-            }
-            const hugged = [...headArgs, group(huggedLastArg, { shouldBreak: true })];
-            const expanded = group([indent([line, ...headArgs, lastArg]), line], {
-                shouldBreak: true
-            });
-            return willBreak(huggedLastArg)
-                ? [breakParent, conditionalGroup([hugged, expanded])]
-                : conditionalGroup([[...headArgs, huggedLastArg], hugged, expanded]);
+        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);
+        return ancestorName &&
+            ["guard", "returnStatement"].includes(ancestorName) &&
+            binaryExpression &&
+            binaryExpression.name === "binaryExpression" &&
+            Object.keys(binaryExpression.children).length === 1
+            ? indentInParentheses(expression)
+            : ["(", indent(expression), ")"];
+    },
+    castExpression: printSingle,
+    primitiveCastExpression(path, print) {
+        return [
+            "(",
+            call(path, print, "primitiveType"),
+            ") ",
+            call(path, print, "unaryExpression")
+        ];
+    },
+    referenceTypeCastExpression(path, print) {
+        const { children } = path.node;
+        const type = call(path, print, "referenceType");
+        const cast = children.additionalBound
+            ? indentInParentheses(join(line, [type, ...map(path, print, "additionalBound")]))
+            : ["(", type, ")"];
+        const expressionKey = onlyDefinedKey(children, [
+            "lambdaExpression",
+            "unaryExpressionNotPlusMinus"
+        ]);
+        return [cast, " ", call(path, print, expressionKey)];
+    },
+    newExpression: printSingle,
+    unqualifiedClassInstanceCreationExpression(path, print) {
+        const { children } = path.node;
+        const expression = ["new "];
+        if (children.typeArguments) {
+            expression.push(call(path, print, "typeArguments"));
         }
-        return group([indent([softline, ...headArgs, lastArg]), softline]);
-    }
-    arrayCreationExpression(ctx) {
-        const type = ctx.primitiveType
-            ? this.visit(ctx.primitiveType)
-            : this.visit(ctx.classOrInterfaceType);
-        const suffix = ctx.arrayCreationExpressionWithoutInitializerSuffix
-            ? this.visit(ctx.arrayCreationExpressionWithoutInitializerSuffix)
-            : this.visit(ctx.arrayCreationWithInitializerSuffix);
-        return rejectAndConcat([concat([ctx.New[0], " "]), type, suffix]);
-    }
-    arrayCreationExpressionWithoutInitializerSuffix(ctx) {
-        const dimExprs = this.visit(ctx.dimExprs);
-        const dims = this.visit(ctx.dims);
-        return rejectAndConcat([dimExprs, dims]);
-    }
-    arrayCreationWithInitializerSuffix(ctx) {
-        const dims = this.visit(ctx.dims);
-        const arrayInitializer = this.visit(ctx.arrayInitializer);
-        return rejectAndJoin(" ", [dims, arrayInitializer]);
-    }
-    dimExprs(ctx) {
-        const dimExpr = this.mapVisit(ctx.dimExpr);
-        return rejectAndConcat(dimExpr);
-    }
-    dimExpr(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const expression = this.visit(ctx.expression);
-        return rejectAndJoin(" ", [
-            rejectAndJoin(" ", annotations),
-            rejectAndConcat([ctx.LSquare[0], expression, ctx.RSquare[0]])
+        expression.push(call(path, print, "classOrInterfaceTypeToInstantiate"), children.argumentList
+            ? group(["(", call(path, print, "argumentList"), ")"])
+            : "()");
+        if (children.classBody) {
+            expression.push(" ", call(path, print, "classBody"));
+        }
+        return expression;
+    },
+    classOrInterfaceTypeToInstantiate(path, print) {
+        const { children } = path.node;
+        const type = children.annotation
+            ? flatMap(path, childPath => [
+                print(childPath),
+                isNonTerminal(childPath.node) ? " " : "."
+            ], ["annotation", "Identifier"])
+            : printName(path, print);
+        if (children.typeArgumentsOrDiamond) {
+            type.push(call(path, print, "typeArgumentsOrDiamond"));
+        }
+        return type;
+    },
+    typeArgumentsOrDiamond: printSingle,
+    diamond() {
+        return "<>";
+    },
+    methodInvocationSuffix(path, print) {
+        return path.node.children.argumentList
+            ? group(["(", call(path, print, "argumentList"), ")"])
+            : indentInParentheses(printDanglingComments(path), { shouldBreak: true });
+    },
+    argumentList(path, print) {
+        var _a, _b, _c, _d;
+        const expressions = path.node.children.expression;
+        const lastExpression = expressions.at(-1);
+        const lastExpressionLambdaBodyExpression = (_b = (_a = lastExpression.children.lambdaExpression) === null || _a === void 0 ? void 0 : _a[0].children.lambdaBody[0].children.expression) === null || _b === void 0 ? void 0 : _b[0].children;
+        const lastExpressionLambdaBodyTernaryExpression = (_c = lastExpressionLambdaBodyExpression === null || lastExpressionLambdaBodyExpression === void 0 ? void 0 : lastExpressionLambdaBodyExpression.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children;
+        const isHuggable = !lastExpression.comments &&
+            (!lastExpressionLambdaBodyExpression ||
+                (lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.QuestionMark) !== undefined ||
+                ((_d = lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.binaryExpression) === null || _d === void 0 ? void 0 : _d[0].children.unaryExpression.length) === 1) &&
+            expressions.findIndex(({ children }) => children.lambdaExpression) ===
+                expressions.length - 1;
+        const args = map(path, print, "expression");
+        const allArgsExpandable = [
+            indent([softline, ...join([",", line], args)]),
+            softline
+        ];
+        if (!isHuggable || willBreak(args.at(-1)[0])) {
+            return allArgsExpandable;
+        }
+        const headArgs = args.slice(0, -1);
+        const huggedLastArg = call(path, argPath => print(argPath, { hug: true }), "expression", args.length - 1);
+        const lastArgExpanded = join(", ", [
+            ...headArgs,
+            group(huggedLastArg, { shouldBreak: true })
         ]);
-    }
-    classLiteralSuffix(ctx) {
-        const squares = [];
-        if (ctx.LSquare) {
-            for (let i = 0; i < ctx.LSquare.length; i++) {
-                squares.push(concat([ctx.LSquare[i], ctx.RSquare[i]]));
-            }
+        if (willBreak(huggedLastArg)) {
+            return [
+                breakParent,
+                conditionalGroup([lastArgExpanded, allArgsExpandable])
+            ];
         }
-        return rejectAndConcat([...squares, ctx.Dot[0], ctx.Class[0]]);
-    }
-    arrayAccessSuffix(ctx) {
-        const expression = this.visit(ctx.expression);
-        return rejectAndConcat([ctx.LSquare[0], expression, ctx.RSquare[0]]);
-    }
-    methodReferenceSuffix(ctx) {
-        const typeArguments = this.visit(ctx.typeArguments);
-        const identifierOrNew = ctx.New ? ctx.New[0] : ctx.Identifier[0];
-        return rejectAndConcat([ctx.ColonColon[0], typeArguments, identifierOrNew]);
-    }
-    templateArgument(ctx) {
-        var _a;
-        return ctx.template
-            ? this.visit(ctx.template)
-            : printTokenWithComments(((_a = ctx.StringLiteral) !== null && _a !== void 0 ? _a : ctx.TextBlock)[0]);
-    }
-    template(ctx) {
-        return this.visitSingle(ctx);
-    }
-    stringTemplate(ctx) {
-        const embeddedExpressions = this.mapVisit(ctx.embeddedExpression).flatMap(expression => group([softline, expression, lineSuffixBoundary, dedent(softline)]));
-        return concat([
-            ctx.StringTemplateBegin[0],
-            rejectAndJoinSeps(ctx.StringTemplateMid, embeddedExpressions),
-            ctx.StringTemplateEnd[0]
+        return conditionalGroup([
+            join(", ", [...headArgs, huggedLastArg]),
+            lastArgExpanded,
+            allArgsExpandable
         ]);
-    }
-    textBlockTemplate(ctx) {
-        const embeddedExpressions = this.mapVisit(ctx.embeddedExpression).flatMap(expression => group([softline, expression, lineSuffixBoundary, dedent(softline)]));
-        return concat([
-            ctx.TextBlockTemplateBegin[0],
-            rejectAndJoinSeps(ctx.TextBlockTemplateMid, embeddedExpressions),
-            ctx.TextBlockTemplateEnd[0]
+    },
+    arrayCreationExpression(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, [
+            "classOrInterfaceType",
+            "primitiveType"
         ]);
-    }
-    embeddedExpression(ctx) {
-        return this.visit(ctx.expression);
-    }
-    pattern(ctx) {
-        return this.visitSingle(ctx);
-    }
-    typePattern(ctx) {
-        return this.visitSingle(ctx);
-    }
-    recordPattern(ctx) {
-        var _a, _b;
-        const componentPatterns = (_b = (_a = ctx.componentPatternList) === null || _a === void 0 ? void 0 : _a[0].children.componentPattern) !== null && _b !== void 0 ? _b : [];
-        handleCommentsParameters(ctx.LBrace[0], componentPatterns, ctx.RBrace[0]);
-        const referenceType = this.visit(ctx.referenceType);
-        const componentPatternList = this.visit(ctx.componentPatternList);
-        return concat([
-            referenceType,
-            putIntoBraces(componentPatternList, softline, ctx.LBrace[0], ctx.RBrace[0])
+        const suffixKey = onlyDefinedKey(children, [
+            "arrayCreationExpressionWithoutInitializerSuffix",
+            "arrayCreationWithInitializerSuffix"
         ]);
-    }
-    componentPatternList(ctx) {
-        var _a, _b;
-        const componentPatterns = this.mapVisit(ctx.componentPattern);
-        const commas = (_b = (_a = ctx.Comma) === null || _a === void 0 ? void 0 : _a.map(elt => concat([elt, line]))) !== null && _b !== void 0 ? _b : [];
-        return rejectAndJoinSeps(commas, componentPatterns);
-    }
-    componentPattern(ctx) {
-        return this.visitSingle(ctx);
-    }
-    matchAllPattern(ctx) {
-        return printTokenWithComments(ctx.Underscore[0]);
-    }
-    guard(ctx) {
-        const expression = this.visit(ctx.expression, {
-            addParenthesisToWrapStatement: true
-        });
-        return concat([ctx.When[0], " ", expression]);
-    }
-    isRefTypeInMethodRef() {
-        return "isRefTypeInMethodRef";
-    }
-    isArgumentListHuggable(argumentList) {
-        var _a, _b, _c;
-        const expressions = argumentList.expression;
-        const lastArgument = expressions.at(-1);
-        const lastArgumentLambdaBodyExpression = (_b = (_a = lastArgument === null || lastArgument === void 0 ? void 0 : lastArgument.children.lambdaExpression) === null || _a === void 0 ? void 0 : _a[0].children.lambdaBody[0].children.expression) === null || _b === void 0 ? void 0 : _b[0].children;
-        const lastArgumentLambdaBodyTernaryExpression = (_c = lastArgumentLambdaBodyExpression === null || lastArgumentLambdaBodyExpression === void 0 ? void 0 : lastArgumentLambdaBodyExpression.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children;
-        return (!(lastArgument === null || lastArgument === void 0 ? void 0 : lastArgument.leadingComments) &&
-            !(lastArgument === null || lastArgument === void 0 ? void 0 : lastArgument.trailingComments) &&
-            (!lastArgumentLambdaBodyExpression ||
-                (lastArgumentLambdaBodyTernaryExpression === null || lastArgumentLambdaBodyTernaryExpression === void 0 ? void 0 : lastArgumentLambdaBodyTernaryExpression.QuestionMark) !== undefined ||
-                (lastArgumentLambdaBodyTernaryExpression === null || lastArgumentLambdaBodyTernaryExpression === void 0 ? void 0 : lastArgumentLambdaBodyTernaryExpression.binaryExpression[0].children.unaryExpression.length) === 1) &&
-            expressions.findIndex(({ children }) => children.lambdaExpression) ===
-                expressions.length - 1);
-    }
-    isBreakableNewExpression(newExpression) {
-        var _a, _b, _c, _d, _e;
-        const arrayCreationExpression = (_a = newExpression === null || newExpression === void 0 ? void 0 : newExpression.arrayCreationExpression) === null || _a === void 0 ? void 0 : _a[0].children;
-        const classInstanceCreationExpression = (_b = newExpression === null || newExpression === void 0 ? void 0 : newExpression.unqualifiedClassInstanceCreationExpression) === null || _b === void 0 ? void 0 : _b[0].children;
+        return ["new ", call(path, print, typeKey), call(path, print, suffixKey)];
+    },
+    arrayCreationExpressionWithoutInitializerSuffix(path, print) {
+        const expressions = call(path, print, "dimExprs");
+        return path.node.children.dims
+            ? [expressions, call(path, print, "dims")]
+            : expressions;
+    },
+    arrayCreationWithInitializerSuffix(path, print) {
         return [
-            (_c = arrayCreationExpression === null || arrayCreationExpression === void 0 ? void 0 : arrayCreationExpression.classOrInterfaceType) === null || _c === void 0 ? void 0 : _c[0].children.classType[0].children.typeArguments,
-            (_d = arrayCreationExpression === null || arrayCreationExpression === void 0 ? void 0 : arrayCreationExpression.arrayCreationWithInitializerSuffix) === null || _d === void 0 ? void 0 : _d[0].children.arrayInitializer[0].children.variableInitializerList,
-            (_e = classInstanceCreationExpression === null || classInstanceCreationExpression === void 0 ? void 0 : classInstanceCreationExpression.classOrInterfaceTypeToInstantiate[0].children.typeArgumentsOrDiamond) === null || _e === void 0 ? void 0 : _e[0].children.typeArguments,
-            classInstanceCreationExpression === null || classInstanceCreationExpression === void 0 ? void 0 : classInstanceCreationExpression.argumentList
-        ].some(breakablePart => breakablePart !== undefined);
-    }
-    isCapitalizedIdentifier(fqnOrRefType) {
-        var _a, _b, _c;
-        const fqnOrRefTypeParts = [
-            fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartFirst[0],
-            ...((_a = fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartRest) !== null && _a !== void 0 ? _a : [])
+            call(path, print, "dims"),
+            " ",
+            call(path, print, "arrayInitializer")
         ];
-        const nextToLastIdentifier = (_c = (_b = fqnOrRefTypeParts[fqnOrRefTypeParts.length - 2]) === null || _b === void 0 ? void 0 : _b.children.fqnOrRefTypePartCommon[0].children.Identifier) === null || _c === void 0 ? void 0 : _c[0].image;
-        return (!!nextToLastIdentifier &&
-            /^\p{Uppercase_Letter}/u.test(nextToLastIdentifier));
-    }
-    getPrimarySuffixes(ctx, newExpression, isBreakableNewExpression, shouldBreakBeforeMethodInvocations) {
-        if (ctx.primarySuffix === undefined) {
-            return [];
+    },
+    dimExprs(path, print) {
+        return map(path, print, "dimExpr");
+    },
+    dimExpr(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            ["[", call(path, print, "expression"), "]"]
+        ]);
+    },
+    classLiteralSuffix(path, print) {
+        const lSquares = map(path, print, "LSquare");
+        const rSquares = map(path, print, "RSquare");
+        return [
+            ...lSquares.flatMap((lSquare, index) => [lSquare, rSquares[index]]),
+            ".class"
+        ];
+    },
+    arrayAccessSuffix(path, print) {
+        return ["[", call(path, print, "expression"), "]"];
+    },
+    methodReferenceSuffix(path, print) {
+        const { children } = path.node;
+        const reference = ["::"];
+        if (children.typeArguments) {
+            reference.push(call(path, print, "typeArguments"));
         }
-        const suffixes = [];
-        if (newExpression &&
-            !isBreakableNewExpression &&
-            ctx.primarySuffix[0].children.Dot !== undefined) {
-            suffixes.push(softline);
+        reference.push(call(path, print, onlyDefinedKey(children, ["Identifier", "New"])));
+        return reference;
+    },
+    templateArgument: printSingle,
+    template: printSingle,
+    stringTemplate(path, print) {
+        return printTemplate(path, print, "StringTemplateBegin", "StringTemplateMid", "StringTemplateEnd");
+    },
+    textBlockTemplate(path, print) {
+        return printTemplate(path, print, "TextBlockTemplateBegin", "TextBlockTemplateMid", "TextBlockTemplateEnd");
+    },
+    embeddedExpression: printSingle,
+    pattern: printSingle,
+    typePattern: printSingle,
+    recordPattern(path, print) {
+        const patterns = path.node.children.componentPatternList
+            ? indentInParentheses(call(path, print, "componentPatternList"))
+            : "()";
+        return [call(path, print, "referenceType"), patterns];
+    },
+    componentPatternList(path, print) {
+        return printList(path, print, "componentPattern");
+    },
+    componentPattern: printSingle,
+    matchAllPattern: printSingle,
+    guard(path, print) {
+        var _a;
+        const expression = call(path, print, "expression");
+        const hasParentheses = ((_a = path.node.children.expression[0].children.conditionalExpression) === null || _a === void 0 ? void 0 : _a[0].children.binaryExpression[0].children.unaryExpression[0].children.primary[0].children.primaryPrefix[0].children.parenthesisExpression) !==
+            undefined;
+        return [
+            "when ",
+            hasParentheses
+                ? expression
+                : group([
+                    ifBreak("("),
+                    indent([softline, expression]),
+                    softline,
+                    ifBreak(")")
+                ])
+        ];
+    }
+};
+function binary(operands, operators, { hasNonAssignmentOperators = false, isRoot = false, operatorPosition }) {
+    let levelOperator;
+    let levelPrecedence;
+    let level = [];
+    while (operators.length) {
+        const nextOperator = operators[0].image;
+        const nextPrecedence = getOperatorPrecedence(nextOperator);
+        if (levelPrecedence === undefined || nextPrecedence === levelPrecedence) {
+            const { image: operator, doc: operatorDoc } = operators.shift();
+            level.push(operands.shift());
+            if (levelOperator !== undefined &&
+                needsParentheses(levelOperator, operator)) {
+                level = [["(", group(indent(level)), ")"]];
+            }
+            const parts = [" ", operatorDoc, line];
+            if (operatorPosition === "start" && !isAssignmentOperator(operator)) {
+                parts.reverse();
+            }
+            level.push(parts);
+            levelOperator = operator;
+            levelPrecedence = nextPrecedence;
         }
-        suffixes.push(this.visit(ctx.primarySuffix[0]));
-        for (let i = 1; i < ctx.primarySuffix.length; i++) {
-            if (shouldBreakBeforeMethodInvocations &&
-                ctx.primarySuffix[i].children.Dot !== undefined &&
-                ctx.primarySuffix[i - 1].children.methodInvocationSuffix !== undefined) {
-                suffixes.push(softline);
+        else if (nextPrecedence < levelPrecedence) {
+            if (!isRoot) {
+                break;
             }
-            suffixes.push(this.visit(ctx.primarySuffix[i]));
+            level.push(operands.shift());
+            const content = group(indent(level));
+            operands.unshift(levelOperator !== undefined &&
+                needsParentheses(levelOperator, nextOperator)
+                ? ["(", content, ")"]
+                : content);
+            level = [];
+            levelOperator = undefined;
+            levelPrecedence = undefined;
+        }
+        else {
+            const content = binary(operands, operators, { operatorPosition });
+            operands.unshift(levelOperator !== undefined &&
+                needsParentheses(nextOperator, levelOperator)
+                ? ["(", indent(content), ")"]
+                : content);
         }
-        return suffixes;
     }
+    level.push(operands.shift());
+    if (!levelOperator || !isAssignmentOperator(levelOperator)) {
+        return group(level);
+    }
+    if (!isRoot || hasNonAssignmentOperators) {
+        return group(indent(level));
+    }
+    const groupId = Symbol("assignment");
+    return group([
+        level[0],
+        group(indent(level[1]), { id: groupId }),
+        indentIfBreak(level[2], { groupId })
+    ]);
+}
+const precedencesByOperator = new Map([
+    ["||"],
+    ["&&"],
+    ["|"],
+    ["^"],
+    ["&"],
+    ["==", "!="],
+    ["<", ">", "<=", ">=", "instanceof"],
+    ["<<", ">>", ">>>"],
+    ["+", "-"],
+    ["*", "/", "%"]
+].flatMap((operators, index) => operators.map(operator => [operator, index])));
+function getOperatorPrecedence(operator) {
+    var _a;
+    return (_a = precedencesByOperator.get(operator)) !== null && _a !== void 0 ? _a : -1;
+}
+function needsParentheses(operator, parentOperator) {
+    return ((operator === "&&" && parentOperator === "||") ||
+        (["|", "^", "&", "<<", ">>", ">>>"].includes(parentOperator) &&
+            getOperatorPrecedence(operator) >
+                getOperatorPrecedence(parentOperator)) ||
+        [operator, parentOperator].every(o => ["==", "!="].includes(o)) ||
+        [operator, parentOperator].every(o => ["<<", ">>", ">>>"].includes(o)) ||
+        (operator === "*" && parentOperator === "/") ||
+        (operator === "/" && parentOperator === "*") ||
+        (operator === "%" && ["+", "-", "*", "/"].includes(parentOperator)) ||
+        (["*", "/"].includes(operator) && parentOperator === "%"));
+}
+const assignmentOperators = new Set([
+    "=",
+    "*=",
+    "/=",
+    "%=",
+    "+=",
+    "-=",
+    "<<=",
+    ">>=",
+    ">>>=",
+    "&=",
+    "^=",
+    "|="
+]);
+function isAssignmentOperator(operator) {
+    return assignmentOperators.has(operator);
+}
+function isCapitalizedIdentifier(fqnOrRefType) {
+    var _a, _b, _c;
+    const nextToLastIdentifier = (_c = (_b = [
+        fqnOrRefType.fqnOrRefTypePartFirst[0],
+        ...((_a = fqnOrRefType.fqnOrRefTypePartRest) !== null && _a !== void 0 ? _a : [])
+    ].at(-2)) === null || _b === void 0 ? void 0 : _b.children.fqnOrRefTypePartCommon[0].children.Identifier) === null || _c === void 0 ? void 0 : _c[0].image;
+    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);
+    const lines = [begin, ...mids, end].join("").split("\n").slice(1);
+    const baseIndent = findBaseIndent(lines);
+    const prefix = "\n" + " ".repeat(baseIndent);
+    const parts = [begin, ...mids, end].map(image => join(hardline, image.split(prefix)));
+    return [
+        parts[0],
+        ...map(path, (expressionPath, index) => {
+            const expression = group([
+                indent([softline, print(expressionPath), lineSuffixBoundary]),
+                softline
+            ]);
+            return index === 0 ? expression : [parts[index], expression];
+        }, "embeddedExpression"),
+        parts.at(-1)
+    ];
 }