prettier-plugin-java 2.6.8 → 2.7.1

package/dist/printers/classes.js

@@ -1,709 +1,446 @@
-import forEach from "lodash/forEach.js";
-import { displaySemicolon, getBlankLinesSeparator, getClassBodyDeclarationsSeparator, isStatementEmptyStatement, putIntoBraces, reject, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortClassTypeChildren, sortModifiers } from "./printer-utils.js";
-import { concat, group, indent, join, indentIfBreak } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { hasLeadingComments, hasLeadingLineComments } from "./comments/comments-utils.js";
-import { handleCommentsParameters } from "./comments/handle-comments.js";
 import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { isAnnotationCstNode, isTypeArgumentsCstNode } from "../types/utils.js";
-import { printArgumentListWithBraces } from "../utils/index.js";
-const { line, softline, hardline, lineSuffixBoundary } = builders;
-export class ClassesPrettierVisitor extends BaseCstPrettierPrinter {
-    classDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.classModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        let classCST;
-        if (ctx.normalClassDeclaration !== undefined) {
-            classCST = ctx.normalClassDeclaration;
-        }
-        else if (ctx.enumDeclaration !== undefined) {
-            classCST = ctx.enumDeclaration;
+import { call, each, hasDeclarationAnnotations, hasLeadingComments, indentInParentheses, isBinaryExpression, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printClassPermits, printClassType, printDanglingComments, printList, printSingle, printWithModifiers } from "./helpers.js";
+const { group, hardline, indent, indentIfBreak, join, line, softline } = builders;
+export default {
+    classDeclaration(path, print) {
+        const declarationKey = onlyDefinedKey(path.node.children, [
+            "enumDeclaration",
+            "normalClassDeclaration",
+            "recordDeclaration"
+        ]);
+        const declaration = call(path, print, declarationKey);
+        return printWithModifiers(path, print, "classModifier", declaration, true);
+    },
+    normalClassDeclaration(path, print) {
+        const { classExtends, classImplements, classPermits, typeParameters } = path.node.children;
+        const header = ["class ", call(path, print, "typeIdentifier")];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
         }
-        else {
-            classCST = ctx.recordDeclaration;
+        if (classExtends) {
+            header.push(indent([line, call(path, print, "classExtends")]));
+        }
+        if (classImplements) {
+            header.push(indent([line, call(path, print, "classImplements")]));
+        }
+        if (classPermits) {
+            header.push(indent([line, call(path, print, "classPermits")]));
         }
-        const classDoc = this.visit(classCST);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [join(" ", otherModifiers), classDoc])
+        return [group(header), " ", call(path, print, "classBody")];
+    },
+    classModifier: printSingle,
+    typeParameters(path, print) {
+        return group([
+            "<",
+            indent([softline, call(path, print, "typeParameterList")]),
+            softline,
+            ">"
         ]);
-    }
-    normalClassDeclaration(ctx) {
-        const name = this.visit(ctx.typeIdentifier);
-        const optionalTypeParams = this.visit(ctx.typeParameters);
-        const optionalClassExtends = this.visit(ctx.classExtends);
-        const optionalClassImplements = this.visit(ctx.classImplements);
-        const optionalClassPermits = this.visit(ctx.classPermits);
-        const body = this.visit(ctx.classBody, { isNormalClassDeclaration: true });
-        let superClassesPart = "";
-        if (optionalClassExtends) {
-            superClassesPart = indent(rejectAndConcat([line, optionalClassExtends]));
-        }
-        let superInterfacesPart = "";
-        if (optionalClassImplements) {
-            superInterfacesPart = indent(rejectAndConcat([line, optionalClassImplements]));
-        }
-        let classPermits = "";
-        if (optionalClassPermits) {
-            classPermits = indent(rejectAndConcat([line, optionalClassPermits]));
-        }
-        return rejectAndJoin(" ", [
-            group(rejectAndConcat([
-                rejectAndJoin(" ", [ctx.Class[0], name]),
-                optionalTypeParams,
-                superClassesPart,
-                superInterfacesPart,
-                classPermits
-            ])),
-            body
+    },
+    typeParameterList(path, print) {
+        return printList(path, print, "typeParameter");
+    },
+    classExtends(path, print) {
+        return ["extends ", call(path, print, "classType")];
+    },
+    classImplements(path, print) {
+        return group([
+            "implements",
+            indent([line, call(path, print, "interfaceTypeList")])
         ]);
-    }
-    classModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visit(ctx.annotation);
-        }
-        // public | protected | private | ...
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    typeParameters(ctx) {
-        const typeParameterList = this.visit(ctx.typeParameterList);
-        return putIntoBraces(typeParameterList, softline, ctx.Less[0], ctx.Greater[0]);
-    }
-    typeParameterList(ctx) {
-        const typeParameter = this.mapVisit(ctx.typeParameter);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndJoinSeps(commas, typeParameter));
-    }
-    classExtends(ctx) {
-        return join(" ", [ctx.Extends[0], this.visit(ctx.classType)]);
-    }
-    classImplements(ctx) {
-        const interfaceTypeList = this.visit(ctx.interfaceTypeList);
-        return group(rejectAndConcat([
-            ctx.Implements[0],
-            indent(rejectAndConcat([line, interfaceTypeList]))
-        ]));
-    }
-    classPermits(ctx) {
-        const typeNames = this.mapVisit(ctx.typeName);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndConcat([
-            ctx.Permits[0],
-            indent(rejectAndConcat([line, group(rejectAndJoinSeps(commas, typeNames))]))
-        ]));
-    }
-    interfaceTypeList(ctx) {
-        const interfaceType = this.mapVisit(ctx.interfaceType);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndJoinSeps(commas, interfaceType));
-    }
-    classBody(ctx, param) {
-        let content = "";
-        if (ctx.classBodyDeclaration !== undefined) {
-            const classBodyDeclsVisited = reject(this.mapVisit(ctx.classBodyDeclaration));
-            const separators = getClassBodyDeclarationsSeparator(ctx.classBodyDeclaration);
-            content = rejectAndJoinSeps(separators, classBodyDeclsVisited);
-            // edge case when we have SemiColons
-            let shouldHardline = false;
-            ctx.classBodyDeclaration.forEach(elt => {
-                if ((elt.children.classMemberDeclaration &&
-                    !elt.children.classMemberDeclaration[0].children.Semicolon) ||
-                    elt.children.constructorDeclaration) {
-                    shouldHardline = true;
-                }
-            });
-            if ((ctx.classBodyDeclaration[0].children.classMemberDeclaration ||
-                ctx.classBodyDeclaration[0].children.constructorDeclaration) &&
-                shouldHardline &&
-                param &&
-                param.isNormalClassDeclaration) {
-                content = rejectAndConcat([hardline, content]);
-            }
+    },
+    classPermits: printClassPermits,
+    interfaceTypeList(path, print) {
+        return group(printList(path, print, "interfaceType"));
+    },
+    classBody(path, print) {
+        return printBlock(path, printClassBodyDeclarations(path, print));
+    },
+    classBodyDeclaration: printSingle,
+    classMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    fieldDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "variableDeclaratorList"),
+            ";"
+        ];
+        return printWithModifiers(path, print, "fieldModifier", declaration);
+    },
+    fieldModifier: printSingle,
+    variableDeclaratorList(path, print) {
+        var _a;
+        const declarators = map(path, print, "variableDeclarator");
+        return declarators.length > 1 &&
+            path.node.children.variableDeclarator.some(({ children }) => children.Equals)
+            ? group(indent(join([",", line], declarators)), {
+                shouldBreak: ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) !== "forInit"
+            })
+            : join(", ", declarators);
+    },
+    variableDeclarator(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        const variableInitializer = (_a = children.variableInitializer) === null || _a === void 0 ? void 0 : _a[0];
+        const declaratorId = call(path, print, "variableDeclaratorId");
+        if (!variableInitializer) {
+            return declaratorId;
         }
-        return putIntoBraces(content, hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    classBodyDeclaration(ctx) {
-        return this.visitSingle(ctx);
-    }
-    classMemberDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return displaySemicolon(ctx.Semicolon[0]);
+        const expression = (_b = variableInitializer.children.expression) === null || _b === void 0 ? void 0 : _b[0];
+        const declarator = [declaratorId, " ", call(path, print, "Equals")];
+        const initializer = call(path, print, "variableInitializer");
+        if (hasLeadingComments(variableInitializer) ||
+            (expression && isBinaryExpression(expression))) {
+            declarator.push(group(indent([line, initializer])));
         }
-        return this.visitSingle(ctx);
-    }
-    fieldDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.fieldModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const unannType = this.visit(ctx.unannType);
-        const variableDeclaratorList = this.visit(ctx.variableDeclaratorList);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                unannType,
-                concat([variableDeclaratorList, ctx.Semicolon[0]])
-            ])
-        ]);
-    }
-    fieldModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visit(ctx.annotation);
+        else {
+            const groupId = Symbol("assignment");
+            declarator.push(group(indent(line), { id: groupId }), indentIfBreak(initializer, { groupId }));
         }
-        // public | protected | private | ...
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    variableDeclaratorList(ctx) {
-        const variableDeclarators = this.mapVisit(ctx.variableDeclarator);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, " "])) : [];
-        return rejectAndJoinSeps(commas, variableDeclarators);
-    }
-    variableDeclarator(ctx) {
-        const variableDeclaratorId = this.visit(ctx.variableDeclaratorId);
-        if (ctx.Equals) {
-            const variableInitializer = this.visit(ctx.variableInitializer);
-            if (hasLeadingLineComments(ctx.variableInitializer[0])) {
-                return group(indent(rejectAndJoin(hardline, [
-                    rejectAndJoin(" ", [variableDeclaratorId, ctx.Equals[0]]),
-                    variableInitializer
-                ])));
-            }
-            if (
-            // Array Initialisation
-            ctx.variableInitializer[0].children.arrayInitializer !== undefined ||
-                // Lambda expression
-                ctx.variableInitializer[0].children.expression[0].children
-                    .lambdaExpression !== undefined ||
-                // Ternary Expression
-                (ctx.variableInitializer[0].children.expression[0].children
-                    .conditionalExpression !== undefined &&
-                    ctx.variableInitializer[0].children.expression[0].children
-                        .conditionalExpression[0].children.QuestionMark !== undefined)) {
-                const groupId = Symbol("assignment");
-                return group([
-                    group(variableDeclaratorId),
-                    " ",
-                    ctx.Equals[0],
-                    group(indent(line), { id: groupId }),
-                    lineSuffixBoundary,
-                    indentIfBreak(variableInitializer, { groupId })
-                ]);
-            }
-            if (ctx.variableInitializer[0].children.expression[0].children
-                .conditionalExpression !== undefined) {
-                const unaryExpressions = ctx.variableInitializer[0].children.expression[0].children
-                    .conditionalExpression[0].children.binaryExpression[0].children
-                    .unaryExpression;
-                const firstPrimary = unaryExpressions[0].children.primary[0];
-                // Cast Expression
-                if (firstPrimary.children.primaryPrefix[0].children.castExpression !==
-                    undefined &&
-                    unaryExpressions.length === 1) {
-                    const groupId = Symbol("assignment");
-                    return group([
-                        group(variableDeclaratorId),
-                        " ",
-                        ctx.Equals[0],
-                        group(indent(line), { id: groupId }),
-                        lineSuffixBoundary,
-                        indentIfBreak(variableInitializer, { groupId })
-                    ]);
-                }
-                // New Expression
-                if (firstPrimary.children.primaryPrefix[0].children.newExpression !==
-                    undefined) {
-                    const groupId = Symbol("assignment");
-                    return group([
-                        group(variableDeclaratorId),
-                        " ",
-                        ctx.Equals[0],
-                        group(indent(line), { id: groupId }),
-                        lineSuffixBoundary,
-                        indentIfBreak(variableInitializer, { groupId })
-                    ]);
-                }
-                // Method Invocation
-                const isMethodInvocation = firstPrimary.children.primarySuffix !== undefined &&
-                    firstPrimary.children.primarySuffix[0].children
-                        .methodInvocationSuffix !== undefined;
-                const isUniqueUnaryExpression = ctx.variableInitializer[0].children.expression[0].children
-                    .conditionalExpression[0].children.binaryExpression[0].children
-                    .unaryExpression.length === 1;
-                const isUniqueMethodInvocation = isMethodInvocation && isUniqueUnaryExpression;
-                if (isUniqueMethodInvocation) {
-                    const groupId = Symbol("assignment");
-                    return group([
-                        group(variableDeclaratorId),
-                        " ",
-                        ctx.Equals[0],
-                        group(indent(line), { id: groupId }),
-                        lineSuffixBoundary,
-                        indentIfBreak(variableInitializer, { groupId })
-                    ]);
-                }
-            }
-            return group(indent(rejectAndJoin(line, [
-                rejectAndJoin(" ", [variableDeclaratorId, ctx.Equals[0]]),
-                variableInitializer
-            ])));
+        return group(declarator);
+    },
+    variableDeclaratorId(path, print) {
+        const { dims, Underscore } = path.node.children;
+        if (Underscore) {
+            return "_";
         }
-        return variableDeclaratorId;
-    }
-    variableDeclaratorId(ctx) {
-        if (ctx.Underscore) {
-            return printTokenWithComments(ctx.Underscore[0]);
+        const identifier = call(path, print, "Identifier");
+        return dims ? [identifier, call(path, print, "dims")] : identifier;
+    },
+    variableInitializer: printSingle,
+    unannType: printSingle,
+    unannPrimitiveTypeWithOptionalDimsSuffix(path, print) {
+        const type = call(path, print, "unannPrimitiveType");
+        return path.node.children.dims ? [type, call(path, print, "dims")] : type;
+    },
+    unannPrimitiveType: printSingle,
+    unannReferenceType(path, print) {
+        const type = call(path, print, "unannClassOrInterfaceType");
+        return path.node.children.dims ? [type, call(path, print, "dims")] : type;
+    },
+    unannClassOrInterfaceType: printSingle,
+    unannClassType: printClassType,
+    unannInterfaceType: printSingle,
+    unannTypeVariable: printSingle,
+    methodDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "methodHeader"),
+            path.node.children.methodBody[0].children.Semicolon ? "" : " ",
+            call(path, print, "methodBody")
+        ];
+        return printWithModifiers(path, print, "methodModifier", declaration);
+    },
+    methodModifier: printSingle,
+    methodHeader(path, print) {
+        const { typeParameters, annotation, throws } = path.node.children;
+        const header = [];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
         }
-        const identifier = ctx.Identifier[0];
-        const dims = this.visit(ctx.dims);
-        return rejectAndConcat([identifier, dims]);
-    }
-    variableInitializer(ctx) {
-        return this.visitSingle(ctx);
-    }
-    unannType(ctx) {
-        return this.visitSingle(ctx);
-    }
-    unannPrimitiveTypeWithOptionalDimsSuffix(ctx) {
-        const unannPrimitiveType = this.visit(ctx.unannPrimitiveType);
-        const dims = this.visit(ctx.dims);
-        return rejectAndConcat([unannPrimitiveType, dims]);
-    }
-    unannPrimitiveType(ctx) {
-        if (ctx.numericType) {
-            return this.visitSingle(ctx);
+        if (annotation) {
+            header.push(join(line, map(path, print, "annotation")));
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    unannReferenceType(ctx) {
-        const unannClassOrInterfaceType = this.visit(ctx.unannClassOrInterfaceType);
-        const dims = this.visit(ctx.dims);
-        return rejectAndConcat([unannClassOrInterfaceType, dims]);
-    }
-    unannClassOrInterfaceType(ctx) {
-        return this.visit(ctx.unannClassType);
-    }
-    unannClassType(ctx) {
-        const tokens = sortClassTypeChildren(ctx.annotation, ctx.typeArguments, ctx.Identifier);
-        const segments = [];
-        let currentSegment = [];
-        forEach(tokens, (token, i) => {
-            if (isTypeArgumentsCstNode(token)) {
-                currentSegment.push(this.visit([token]));
-                segments.push(rejectAndConcat(currentSegment));
-                currentSegment = [];
-            }
-            else if (isAnnotationCstNode(token)) {
-                currentSegment.push(this.visit([token]));
-                currentSegment.push(" ");
-            }
-            else {
-                currentSegment.push(token);
-                if ((i + 1 < tokens.length && !isTypeArgumentsCstNode(tokens[i + 1])) ||
-                    i + 1 === tokens.length) {
-                    segments.push(rejectAndConcat(currentSegment));
-                    currentSegment = [];
-                }
-            }
-        });
-        return rejectAndJoinSeps(ctx.Dot, segments);
-    }
-    unannInterfaceType(ctx) {
-        return this.visit(ctx.unannClassType);
-    }
-    unannTypeVariable(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    methodDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.methodModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const header = this.visit(ctx.methodHeader);
-        const body = this.visit(ctx.methodBody);
-        const headerBodySeparator = isStatementEmptyStatement(body) ? "" : " ";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                rejectAndJoin(headerBodySeparator, [header, body])
+        header.push(call(path, print, "result"), call(path, print, "methodDeclarator"));
+        return throws
+            ? group([
+                ...join(" ", header),
+                group(indent([line, call(path, print, "throws")]))
             ])
-        ]);
-    }
-    methodModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visit(ctx.annotation);
+            : group(join(" ", header));
+    },
+    result: printSingle,
+    methodDeclarator(path, print) {
+        const { dims, formalParameterList, receiverParameter } = path.node.children;
+        const declarator = [call(path, print, "Identifier")];
+        const parameters = [];
+        if (receiverParameter) {
+            parameters.push(call(path, print, "receiverParameter"));
         }
-        // public | protected | private | Synchronized | ...
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    methodHeader(ctx) {
-        const typeParameters = this.visit(ctx.typeParameters);
-        const annotations = this.mapVisit(ctx.annotation);
-        const result = this.visit(ctx.result);
-        const declarator = this.visit(ctx.methodDeclarator);
-        const throws = this.visit(ctx.throws);
-        return group(concat([
-            rejectAndJoin(" ", [
-                typeParameters,
-                rejectAndJoin(line, annotations),
-                result,
-                declarator,
-                throws
-            ])
-        ]));
-    }
-    result(ctx) {
-        if (ctx.unannType) {
-            return this.visit(ctx.unannType);
+        if (formalParameterList) {
+            parameters.push(call(path, print, "formalParameterList"));
         }
-        // void
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    methodDeclarator(ctx) {
-        var _a, _b, _c, _d;
-        const parameters = [
-            ...((_a = ctx.receiverParameter) !== null && _a !== void 0 ? _a : []),
-            ...((_c = (_b = ctx.formalParameterList) === null || _b === void 0 ? void 0 : _b[0].children.formalParameter) !== null && _c !== void 0 ? _c : [])
-        ];
-        handleCommentsParameters(ctx.LBrace[0], parameters, ctx.RBrace[0]);
-        const identifier = printTokenWithComments(ctx.Identifier[0]);
-        const receiverParameter = this.visit(ctx.receiverParameter);
-        const formalParameterList = this.visit(ctx.formalParameterList);
-        const dims = this.visit(ctx.dims);
-        return rejectAndConcat([
-            identifier,
-            putIntoBraces(rejectAndJoin(line, [
-                rejectAndConcat([receiverParameter, (_d = ctx.Comma) === null || _d === void 0 ? void 0 : _d[0]]),
-                formalParameterList
-            ]), softline, ctx.LBrace[0], ctx.RBrace[0]),
-            dims
+        const items = parameters.length
+            ? join([",", line], parameters)
+            : printDanglingComments(path);
+        declarator.push(items.length ? indentInParentheses(items) : "()");
+        if (dims) {
+            declarator.push(call(path, print, "dims"));
+        }
+        return declarator;
+    },
+    receiverParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "unannType"),
+            path.node.children.Identifier
+                ? [call(path, print, "Identifier"), ".this"]
+                : "this"
         ]);
-    }
-    receiverParameter(ctx) {
-        var _a, _b;
-        const annotations = this.mapVisit(ctx.annotation);
-        const unannType = this.visit(ctx.unannType);
-        return rejectAndJoin(" ", [
-            ...annotations,
-            unannType,
-            rejectAndConcat([(_a = ctx.Identifier) === null || _a === void 0 ? void 0 : _a[0], (_b = ctx.Dot) === null || _b === void 0 ? void 0 : _b[0], ctx.This[0]])
+    },
+    formalParameterList(path, print) {
+        return printList(path, print, "formalParameter");
+    },
+    formalParameter: printSingle,
+    variableParaRegularParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "unannType"),
+            call(path, print, "variableDeclaratorId")
         ]);
-    }
-    formalParameterList(ctx) {
-        const formalParameter = this.mapVisit(ctx.formalParameter);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return rejectAndJoinSeps(commas, formalParameter);
-    }
-    formalParameter(ctx) {
-        return this.visitSingle(ctx);
-    }
-    variableParaRegularParameter(ctx) {
-        const variableModifier = this.mapVisit(ctx.variableModifier);
-        const unannType = this.visit(ctx.unannType);
-        const variableDeclaratorId = this.visit(ctx.variableDeclaratorId);
-        return rejectAndJoin(" ", [
-            rejectAndJoin(" ", variableModifier),
-            unannType,
-            variableDeclaratorId
-        ]);
-    }
-    variableArityParameter(ctx) {
-        const variableModifier = this.mapVisit(ctx.variableModifier);
-        const unannType = this.visit(ctx.unannType);
-        const annotations = this.mapVisit(ctx.annotation);
-        const identifier = ctx.Identifier[0];
-        const unannTypePrinted = ctx.annotation === undefined
-            ? concat([unannType, ctx.DotDotDot[0]])
-            : unannType;
-        const annotationsPrinted = ctx.annotation === undefined
-            ? annotations
-            : concat([rejectAndJoin(" ", annotations), ctx.DotDotDot[0]]);
-        return rejectAndJoin(" ", [
-            join(" ", variableModifier),
-            unannTypePrinted,
-            annotationsPrinted,
-            identifier
+    },
+    variableArityParameter(path, print) {
+        const type = join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "unannType"),
+            ...map(path, print, "annotation")
         ]);
-    }
-    variableModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visit(ctx.annotation);
+        return [type, "... ", call(path, print, "Identifier")];
+    },
+    variableModifier: printSingle,
+    throws(path, print) {
+        return ["throws ", call(path, print, "exceptionTypeList")];
+    },
+    exceptionTypeList(path, print) {
+        return join(", ", map(path, print, "exceptionType"));
+    },
+    exceptionType: printSingle,
+    methodBody: printSingle,
+    instanceInitializer: printSingle,
+    staticInitializer(path, print) {
+        return ["static ", call(path, print, "block")];
+    },
+    constructorDeclaration(path, print) {
+        const declaration = [call(path, print, "constructorDeclarator")];
+        if (path.node.children.throws) {
+            declaration.push(group(indent([line, call(path, print, "throws")])));
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    throws(ctx) {
-        const exceptionTypeList = this.visit(ctx.exceptionTypeList);
-        const throwsDeclaration = join(" ", [ctx.Throws[0], exceptionTypeList]);
-        return group(indent(rejectAndConcat([softline, throwsDeclaration])));
-    }
-    exceptionTypeList(ctx) {
-        const exceptionTypes = this.mapVisit(ctx.exceptionType);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, " "])) : [];
-        return rejectAndJoinSeps(commas, exceptionTypes);
-    }
-    exceptionType(ctx) {
-        return this.visitSingle(ctx);
-    }
-    methodBody(ctx) {
-        if (ctx.block) {
-            return this.visit(ctx.block);
+        declaration.push(" ", call(path, print, "constructorBody"));
+        return printWithModifiers(path, print, "constructorModifier", declaration, true);
+    },
+    constructorModifier: printSingle,
+    constructorDeclarator(path, print) {
+        const { children } = path.node;
+        const parameters = [];
+        if (children.receiverParameter) {
+            parameters.push(call(path, print, "receiverParameter"));
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    instanceInitializer(ctx) {
-        return this.visitSingle(ctx);
-    }
-    staticInitializer(ctx) {
-        const block = this.visit(ctx.block);
-        return join(" ", [ctx.Static[0], block]);
-    }
-    constructorDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.constructorModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const constructorDeclarator = this.visit(ctx.constructorDeclarator);
-        const throws = this.visit(ctx.throws);
-        const constructorBody = this.visit(ctx.constructorBody);
-        return rejectAndJoin(" ", [
-            group(rejectAndJoin(hardline, [
-                rejectAndJoin(hardline, firstAnnotations),
-                rejectAndJoin(" ", [
-                    join(" ", otherModifiers),
-                    constructorDeclarator,
-                    throws
-                ])
-            ])),
-            constructorBody
-        ]);
-    }
-    constructorModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visit(ctx.annotation);
+        if (children.formalParameterList) {
+            parameters.push(call(path, print, "formalParameterList"));
         }
-        // public | protected | private | Synchronized | ...
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    constructorDeclarator(ctx) {
-        var _a, _b, _c, _d;
-        const parameters = (_c = (_a = ctx.receiverParameter) !== null && _a !== void 0 ? _a : (_b = ctx.formalParameterList) === null || _b === void 0 ? void 0 : _b[0].children.formalParameter) !== null && _c !== void 0 ? _c : [];
-        handleCommentsParameters(ctx.LBrace[0], parameters, ctx.RBrace[0]);
-        const typeParameters = this.visit(ctx.typeParameters);
-        const simpleTypeName = this.visit(ctx.simpleTypeName);
-        const receiverParameter = this.visit(ctx.receiverParameter);
-        const formalParameterList = this.visit(ctx.formalParameterList);
-        return rejectAndJoin(" ", [
-            typeParameters,
-            concat([
-                simpleTypeName,
-                putIntoBraces(rejectAndJoin(line, [
-                    rejectAndConcat([receiverParameter, (_d = ctx.Comma) === null || _d === void 0 ? void 0 : _d[0]]),
-                    formalParameterList
-                ]), softline, ctx.LBrace[0], ctx.RBrace[0])
-            ])
-        ]);
-    }
-    simpleTypeName(ctx) {
-        return this.visitSingle(ctx);
-    }
-    constructorBody(ctx) {
-        const explicitConstructorInvocation = this.visit(ctx.explicitConstructorInvocation);
-        const blockStatements = this.visit(ctx.blockStatements);
-        return putIntoBraces(rejectAndJoin(hardline, [explicitConstructorInvocation, blockStatements]), hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    explicitConstructorInvocation(ctx) {
-        return this.visitSingle(ctx);
-    }
-    unqualifiedExplicitConstructorInvocation(ctx) {
-        const typeArguments = this.visit(ctx.typeArguments);
-        const keyWord = ctx.This ? ctx.This[0] : ctx.Super[0];
-        const argumentList = printArgumentListWithBraces.call(this, ctx.argumentList, ctx.RBrace[0], ctx.LBrace[0]);
-        return rejectAndConcat([
-            typeArguments,
-            keyWord,
-            group(rejectAndConcat([argumentList, ctx.Semicolon[0]]))
-        ]);
-    }
-    qualifiedExplicitConstructorInvocation(ctx) {
-        const expressionName = this.visit(ctx.expressionName);
-        const typeArguments = this.visit(ctx.typeArguments);
-        const argumentList = printArgumentListWithBraces.call(this, ctx.argumentList, ctx.RBrace[0], ctx.LBrace[0]);
-        return rejectAndConcat([
-            expressionName,
-            ctx.Dot[0],
-            typeArguments,
-            ctx.Super[0],
-            group(rejectAndConcat([argumentList, ctx.Semicolon[0]]))
-        ]);
-    }
-    enumDeclaration(ctx) {
-        const classModifier = this.mapVisit(ctx.classModifier);
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const classImplements = this.visit(ctx.classImplements);
-        const enumBody = this.visit(ctx.enumBody);
-        return rejectAndJoin(" ", [
-            join(" ", classModifier),
-            ctx.Enum[0],
-            typeIdentifier,
-            classImplements,
-            enumBody
-        ]);
-    }
-    enumBody(ctx) {
-        const enumConstantList = this.visit(ctx.enumConstantList);
-        const enumBodyDeclarations = this.visit(ctx.enumBodyDeclarations);
-        const hasEnumConstants = ctx.enumConstantList !== undefined;
-        const hasNoClassBodyDeclarations = ctx.enumBodyDeclarations === undefined ||
-            ctx.enumBodyDeclarations[0].children.classBodyDeclaration === undefined;
-        // edge case: https://github.com/jhipster/prettier-java/issues/383
-        const handleEnumBodyDeclarationsLeadingComments = !hasNoClassBodyDeclarations &&
-            hasLeadingComments(ctx.enumBodyDeclarations[0])
-            ? hardline
-            : "";
-        let optionalComma;
-        if (hasEnumConstants &&
-            hasNoClassBodyDeclarations &&
-            this.prettierOptions.trailingComma !== "none") {
-            optionalComma = ctx.Comma ? ctx.Comma[0] : ",";
+        const header = [call(path, print, "simpleTypeName")];
+        header.push(parameters.length
+            ? indentInParentheses(join([",", line], parameters))
+            : "()");
+        return children.typeParameters
+            ? [call(path, print, "typeParameters"), " ", ...header]
+            : header;
+    },
+    simpleTypeName: printSingle,
+    constructorBody(path, print) {
+        const { children } = path.node;
+        const statements = [];
+        if (children.explicitConstructorInvocation) {
+            statements.push(call(path, print, "explicitConstructorInvocation"));
+        }
+        if (children.blockStatements) {
+            statements.push(call(path, print, "blockStatements"));
+        }
+        return printBlock(path, statements);
+    },
+    explicitConstructorInvocation: printSingle,
+    unqualifiedExplicitConstructorInvocation(path, print) {
+        const { children } = path.node;
+        const invocation = [];
+        if (children.typeArguments) {
+            invocation.push(call(path, print, "typeArguments"));
+        }
+        invocation.push(children.Super ? "super" : "this");
+        if (children.argumentList) {
+            invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
         }
         else {
-            optionalComma = ctx.Comma ? Object.assign(Object.assign({}, ctx.Comma[0]), { image: "" }) : "";
-        }
-        return putIntoBraces(rejectAndConcat([
-            enumConstantList,
-            optionalComma,
-            handleEnumBodyDeclarationsLeadingComments,
-            enumBodyDeclarations
-        ]), hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    enumConstantList(ctx) {
-        const enumConstants = this.mapVisit(ctx.enumConstant);
-        const blankLineSeparators = getBlankLinesSeparator(ctx.enumConstant);
-        const commas = ctx.Comma
-            ? ctx.Comma.map((elt, index) => concat([elt, blankLineSeparators[index]]))
-            : [];
-        return group(rejectAndJoinSeps(commas, enumConstants));
-    }
-    enumConstant(ctx) {
-        const modifiers = sortModifiers(ctx.enumConstantModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const identifier = ctx.Identifier[0];
-        const classBody = this.visit(ctx.classBody);
-        const optionalBracesAndArgumentList = ctx.LBrace
-            ? printArgumentListWithBraces.call(this, ctx.argumentList, ctx.RBrace[0], ctx.LBrace[0])
-            : "";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                rejectAndConcat([identifier, optionalBracesAndArgumentList]),
-                classBody
-            ])
-        ]);
-    }
-    enumConstantModifier(ctx) {
-        return this.visitSingle(ctx);
-    }
-    enumBodyDeclarations(ctx) {
-        if (ctx.classBodyDeclaration !== undefined) {
-            const classBodyDeclaration = this.mapVisit(ctx.classBodyDeclaration);
-            const separators = getClassBodyDeclarationsSeparator(ctx.classBodyDeclaration);
-            return rejectAndJoin(concat([hardline, hardline]), [
-                ctx.Semicolon[0],
-                rejectAndJoinSeps(separators, classBodyDeclaration)
-            ]);
-        }
-        return printTokenWithComments(Object.assign(Object.assign({}, ctx.Semicolon[0]), { image: "" }));
-    }
-    recordDeclaration(ctx) {
-        const name = this.visit(ctx.typeIdentifier);
-        const optionalTypeParams = this.visit(ctx.typeParameters);
-        const recordHeader = this.visit(ctx.recordHeader);
-        let superInterfacesPart = "";
-        const optionalClassImplements = this.visit(ctx.classImplements);
-        if (optionalClassImplements) {
-            superInterfacesPart = indent(rejectAndConcat([line, optionalClassImplements]));
-        }
-        const body = this.visit(ctx.recordBody);
-        return rejectAndJoin(" ", [
-            group(rejectAndConcat([
-                rejectAndJoin(" ", [ctx.Record[0], name]),
-                optionalTypeParams,
-                recordHeader,
-                superInterfacesPart
-            ])),
-            body
-        ]);
-    }
-    recordHeader(ctx) {
-        var _a, _b;
-        const recordComponents = (_b = (_a = ctx.recordComponentList) === null || _a === void 0 ? void 0 : _a[0].children.recordComponent) !== null && _b !== void 0 ? _b : [];
-        handleCommentsParameters(ctx.LBrace[0], recordComponents, ctx.RBrace[0]);
-        const recordComponentList = this.visit(ctx.recordComponentList);
-        return putIntoBraces(recordComponentList, softline, ctx.LBrace[0], ctx.RBrace[0]);
-    }
-    recordComponentList(ctx) {
-        const recordComponents = this.mapVisit(ctx.recordComponent);
-        const blankLineSeparators = getBlankLinesSeparator(ctx.recordComponent, line);
-        const commas = ctx.Comma
-            ? ctx.Comma.map((elt, index) => concat([elt, blankLineSeparators[index]]))
-            : [];
-        return rejectAndJoinSeps(commas, recordComponents);
-    }
-    recordComponent(ctx) {
-        const modifiers = this.mapVisit(ctx.recordComponentModifier);
-        const unannType = this.visit(ctx.unannType);
-        if (ctx.Identifier !== undefined) {
-            return group(rejectAndJoin(line, [
-                join(line, modifiers),
-                join(" ", [unannType, ctx.Identifier[0]])
-            ]));
-        }
-        const variableArityRecordComponent = this.visit(ctx.variableArityRecordComponent);
-        if (ctx.variableArityRecordComponent[0].children.annotation !== undefined) {
-            return group(rejectAndJoin(line, [
-                join(line, modifiers),
-                join(" ", [unannType, variableArityRecordComponent])
-            ]));
-        }
-        return group(rejectAndJoin(line, [
-            join(line, modifiers),
-            concat([unannType, variableArityRecordComponent])
-        ]));
-    }
-    variableArityRecordComponent(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const identifier = ctx.Identifier[0];
-        return rejectAndJoin(" ", [
-            rejectAndConcat([rejectAndJoin(" ", annotations), ctx.DotDotDot[0]]),
-            identifier
-        ]);
-    }
-    recordComponentModifier(ctx) {
-        return this.visitSingle(ctx);
-    }
-    recordBody(ctx) {
-        return putIntoBraces(rejectAndJoinSeps(getBlankLinesSeparator(ctx.recordBodyDeclaration), this.mapVisit(ctx.recordBodyDeclaration)), hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    recordBodyDeclaration(ctx) {
-        return this.visitSingle(ctx);
-    }
-    compactConstructorDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.constructorModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const name = this.visit(ctx.simpleTypeName);
-        const constructorBody = this.visit(ctx.constructorBody);
-        return rejectAndJoin(" ", [
-            group(rejectAndJoin(hardline, [
-                rejectAndJoin(hardline, firstAnnotations),
-                rejectAndJoin(" ", [join(" ", otherModifiers), name])
-            ])),
-            constructorBody
+            invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
+        }
+        invocation.push(";");
+        return invocation;
+    },
+    qualifiedExplicitConstructorInvocation(path, print) {
+        const { children } = path.node;
+        const invocation = [call(path, print, "expressionName"), "."];
+        if (children.typeArguments) {
+            invocation.push(call(path, print, "typeArguments"));
+        }
+        invocation.push("super");
+        if (children.argumentList) {
+            invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
+        }
+        else {
+            invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
+        }
+        invocation.push(";");
+        return invocation;
+    },
+    enumDeclaration(path, print) {
+        const header = ["enum", call(path, print, "typeIdentifier")];
+        if (path.node.children.classImplements) {
+            header.push(call(path, print, "classImplements"));
+        }
+        return join(" ", [...header, call(path, print, "enumBody")]);
+    },
+    enumBody(path, print, options) {
+        var _a;
+        const { children } = path.node;
+        const contents = [];
+        const hasNonEmptyDeclaration = ((_a = children.enumBodyDeclarations) !== null && _a !== void 0 ? _a : [])
+            .flatMap(({ children }) => { var _a; return (_a = children.classBodyDeclaration) !== null && _a !== void 0 ? _a : []; })
+            .some(({ children }) => { var _a; return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon); });
+        if (children.enumConstantList) {
+            contents.push(call(path, print, "enumConstantList"));
+            if (!hasNonEmptyDeclaration && options.trailingComma !== "none") {
+                contents.push(",");
+            }
+        }
+        if (hasNonEmptyDeclaration) {
+            contents.push(";", hardline, call(path, print, "enumBodyDeclarations"));
+        }
+        return printBlock(path, contents.length ? [contents] : []);
+    },
+    enumConstantList(path, print) {
+        return join([",", hardline], map(path, constantPath => {
+            const constant = print(constantPath);
+            const { node, previous } = constantPath;
+            return !previous ||
+                lineStartWithComments(node) <= lineEndWithComments(previous) + 1
+                ? constant
+                : [hardline, constant];
+        }, "enumConstant"));
+    },
+    enumConstant(path, print) {
+        const { argumentList, classBody } = path.node.children;
+        const initializer = [call(path, print, "Identifier")];
+        if (argumentList) {
+            initializer.push(group(["(", call(path, print, "argumentList"), ")"]));
+        }
+        if (classBody) {
+            initializer.push(" ", call(path, print, "classBody"));
+        }
+        return printWithModifiers(path, print, "enumConstantModifier", initializer);
+    },
+    enumConstantModifier: printSingle,
+    enumBodyDeclarations(path, print) {
+        return join(hardline, printClassBodyDeclarations(path, print));
+    },
+    recordDeclaration(path, print) {
+        const { children } = path.node;
+        const header = ["record ", call(path, print, "typeIdentifier")];
+        if (children.typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
+        header.push(call(path, print, "recordHeader"));
+        if (children.classImplements) {
+            header.push(" ", call(path, print, "classImplements"));
+        }
+        return [group(header), " ", call(path, print, "recordBody")];
+    },
+    recordHeader(path, print) {
+        return path.node.children.recordComponentList
+            ? indentInParentheses(call(path, print, "recordComponentList"))
+            : indentInParentheses(printDanglingComments(path), { shouldBreak: true });
+    },
+    recordComponentList(path, print) {
+        return join([",", line], map(path, componentPath => {
+            const { node, previous } = componentPath;
+            const blankLine = previous &&
+                lineStartWithComments(node) > lineEndWithComments(previous) + 1;
+            const component = print(componentPath);
+            return blankLine ? [softline, component] : component;
+        }, "recordComponent"));
+    },
+    recordComponent(path, print) {
+        const { children } = path.node;
+        const component = [call(path, print, "unannType")];
+        if (children.Identifier ||
+            children.variableArityRecordComponent[0].children.annotation) {
+            component.push(" ");
+        }
+        const suffixKey = onlyDefinedKey(children, [
+            "Identifier",
+            "variableArityRecordComponent"
         ]);
-    }
-    isDims() {
-        return "isDims";
-    }
+        component.push(call(path, print, suffixKey));
+        return group(join(line, [...map(path, print, "recordComponentModifier"), component]));
+    },
+    variableArityRecordComponent(path, print) {
+        return [
+            ...join(" ", map(path, print, "annotation")),
+            "... ",
+            call(path, print, "Identifier")
+        ];
+    },
+    recordComponentModifier: printSingle,
+    recordBody(path, print) {
+        const declarations = [];
+        let previousRequiresPadding = false;
+        each(path, declarationPath => {
+            var _a, _b, _c, _d;
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            const { node, previous } = declarationPath;
+            const fieldDeclaration = (_c = (_b = (_a = node.children.classBodyDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.classMemberDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.fieldDeclaration) === null || _c === void 0 ? void 0 : _c[0].children;
+            const currentRequiresPadding = !fieldDeclaration ||
+                hasDeclarationAnnotations((_d = fieldDeclaration.fieldModifier) !== null && _d !== void 0 ? _d : []);
+            const blankLine = declarations.length > 0 &&
+                (previousRequiresPadding ||
+                    currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1);
+            declarations.push(blankLine ? [hardline, declaration] : declaration);
+            previousRequiresPadding = currentRequiresPadding;
+        }, "recordBodyDeclaration");
+        return printBlock(path, declarations);
+    },
+    recordBodyDeclaration: printSingle,
+    compactConstructorDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "simpleTypeName"),
+            " ",
+            call(path, print, "constructorBody")
+        ];
+        return printWithModifiers(path, print, "constructorModifier", declaration, true);
+    }
+};
+function printClassBodyDeclarations(path, print) {
+    var _a;
+    if (!path.node.children.classBodyDeclaration) {
+        return [];
+    }
+    const declarations = [];
+    let previousRequiresPadding = path.node.name === "enumBodyDeclarations" ||
+        ((_a = path.grandparent) === null || _a === void 0 ? void 0 : _a.name) ===
+            "normalClassDeclaration";
+    each(path, declarationPath => {
+        var _a, _b, _c;
+        const declaration = print(declarationPath);
+        if (declaration === "") {
+            return;
+        }
+        const { node, previous } = declarationPath;
+        const fieldDeclaration = (_b = (_a = node.children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.fieldDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
+        const currentRequiresPadding = fieldDeclaration
+            ? hasDeclarationAnnotations((_c = fieldDeclaration.fieldModifier) !== null && _c !== void 0 ? _c : [])
+            : true;
+        const blankLine = previousRequiresPadding ||
+            (declarations.length > 0 &&
+                (currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1));
+        declarations.push(blankLine ? [hardline, declaration] : declaration);
+        previousRequiresPadding = currentRequiresPadding;
+    }, "classBodyDeclaration");
+    return declarations;
 }