prettier-plugin-java 2.6.8 → 2.7.0

package/dist/printers/packages-and-modules.js

@@ -1,171 +1,169 @@
-import { concat, join } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { buildFqn, displaySemicolon, getBlankLinesSeparator, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortImports } from "./printer-utils.js";
 import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { isOrdinaryCompilationUnitCtx } from "../types/utils.js";
-const { line, hardline, indent, group } = builders;
-export class PackagesAndModulesPrettierVisitor extends BaseCstPrettierPrinter {
-    compilationUnit(ctx) {
-        const compilationUnit = isOrdinaryCompilationUnitCtx(ctx)
-            ? ctx.ordinaryCompilationUnit
-            : ctx.modularCompilationUnit;
-        return concat([this.visit(compilationUnit[0]), line]);
-    }
-    ordinaryCompilationUnit(ctx) {
-        const packageDecl = this.visit(ctx.packageDeclaration);
-        const sortedImportsDecl = sortImports(ctx.importDeclaration);
-        const nonStaticImports = this.mapVisit(sortedImportsDecl.nonStaticImports);
-        const staticImports = this.mapVisit(sortedImportsDecl.staticImports);
-        const typesDecl = this.mapVisit(ctx.typeDeclaration);
-        // TODO: utility to add item+line (or multiple lines) but only if an item exists
-        return rejectAndConcat([
-            rejectAndJoin(concat([hardline, hardline]), [
-                packageDecl,
-                rejectAndJoin(hardline, staticImports),
-                rejectAndJoin(hardline, nonStaticImports),
-                rejectAndJoin(concat([hardline, hardline]), typesDecl)
-            ])
-        ]);
-    }
-    modularCompilationUnit(ctx) {
-        const sortedImportsDecl = sortImports(ctx.importDeclaration);
-        const nonStaticImports = this.mapVisit(sortedImportsDecl.nonStaticImports);
-        const staticImports = this.mapVisit(sortedImportsDecl.staticImports);
-        const moduleDeclaration = this.visit(ctx.moduleDeclaration);
-        return rejectAndConcat([
-            rejectAndJoin(concat([hardline, hardline]), [
-                rejectAndJoin(hardline, staticImports),
-                rejectAndJoin(hardline, nonStaticImports),
-                moduleDeclaration
-            ])
-        ]);
-    }
-    packageDeclaration(ctx) {
-        const modifiers = this.mapVisit(ctx.packageModifier);
-        const name = buildFqn(ctx.Identifier, ctx.Dot);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, modifiers),
-            concat([ctx.Package[0], " ", name, ctx.Semicolon[0]])
-        ]);
-    }
-    packageModifier(ctx) {
-        return this.visitSingle(ctx);
-    }
-    importDeclaration(ctx) {
-        if (ctx.emptyStatement !== undefined) {
-            return this.visit(ctx.emptyStatement);
+import { call, lineEndWithComments, lineStartWithComments, map, printBlock, printDanglingComments, printName, printSingle } from "./helpers.js";
+const { group, hardline, indent, join, line } = builders;
+export default {
+    compilationUnit(path, print) {
+        return [...printDanglingComments(path), printSingle(path, print), hardline];
+    },
+    ordinaryCompilationUnit(path, print) {
+        const { children } = path.node;
+        const declarations = [];
+        if (children.packageDeclaration) {
+            declarations.push(call(path, print, "packageDeclaration"));
         }
-        const optionalStatic = ctx.Static ? ctx.Static[0] : "";
-        const packageOrTypeName = this.visit(ctx.packageOrTypeName);
-        const optionalDotStar = ctx.Dot ? concat([ctx.Dot[0], ctx.Star[0]]) : "";
-        return rejectAndJoin(" ", [
-            ctx.Import[0],
-            optionalStatic,
-            rejectAndConcat([packageOrTypeName, optionalDotStar, ctx.Semicolon[0]])
-        ]);
-    }
-    typeDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return displaySemicolon(ctx.Semicolon[0]);
+        if (children.importDeclaration) {
+            const staticCount = sortImports(children.importDeclaration);
+            const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
+            const staticDeclarations = importDeclarations.slice(0, staticCount);
+            const nonStaticDeclarations = importDeclarations.slice(staticCount);
+            declarations.push(...[staticDeclarations, nonStaticDeclarations]
+                .filter(({ length }) => length)
+                .map(declarations => join(hardline, declarations)));
         }
-        return this.visitSingle(ctx);
-    }
-    moduleDeclaration(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const optionalOpen = ctx.Open ? ctx.Open[0] : "";
-        const name = buildFqn(ctx.Identifier, ctx.Dot);
-        const moduleDirectives = this.mapVisit(ctx.moduleDirective);
-        const content = rejectAndJoinSeps(getBlankLinesSeparator(ctx.moduleDirective), moduleDirectives);
-        return rejectAndJoin(" ", [
-            join(" ", annotations),
-            optionalOpen,
-            ctx.Module[0],
-            name,
-            putIntoBraces(content, hardline, ctx.LCurly[0], ctx.RCurly[0])
-        ]);
-    }
-    moduleDirective(ctx) {
-        return this.visitSingle(ctx);
-    }
-    requiresModuleDirective(ctx) {
-        const modifiers = this.mapVisit(ctx.requiresModifier);
-        const moduleName = this.visit(ctx.moduleName);
-        return rejectAndJoin(" ", [
-            ctx.Requires[0],
-            join(" ", modifiers),
-            concat([moduleName, ctx.Semicolon[0]])
-        ]);
-    }
-    exportsModuleDirective(ctx) {
-        const packageName = this.visit(ctx.packageName);
-        const moduleNames = this.mapVisit(ctx.moduleName);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        if (ctx.To) {
-            return group(rejectAndConcat([
-                indent(rejectAndJoin(line, [
-                    rejectAndJoin(" ", [ctx.Exports[0], packageName]),
-                    group(indent(rejectAndJoin(line, [
-                        ctx.To[0],
-                        rejectAndJoinSeps(commas, moduleNames)
-                    ])))
-                ])),
-                ctx.Semicolon[0]
-            ]));
+        if (children.typeDeclaration) {
+            declarations.push(...map(path, print, "typeDeclaration").filter(declaration => declaration !== ""));
         }
-        return rejectAndConcat([
-            concat([ctx.Exports[0], " "]),
-            packageName,
-            ctx.Semicolon[0]
+        return join([hardline, hardline], declarations);
+    },
+    modularCompilationUnit(path, print) {
+        const { children } = path.node;
+        const declarations = [];
+        if (children.importDeclaration) {
+            const staticCount = sortImports(children.importDeclaration);
+            const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
+            const staticDeclarations = importDeclarations.slice(0, staticCount);
+            const nonStaticDeclarations = importDeclarations.slice(staticCount);
+            declarations.push(...[staticDeclarations, nonStaticDeclarations]
+                .filter(({ length }) => length)
+                .map(declarations => join(hardline, declarations)));
+        }
+        declarations.push(call(path, print, "moduleDeclaration"));
+        return join([hardline, hardline], declarations);
+    },
+    packageDeclaration(path, print) {
+        return join(hardline, [
+            ...map(path, print, "packageModifier"),
+            ["package ", printName(path, print), ";"]
         ]);
-    }
-    opensModuleDirective(ctx) {
-        const packageName = this.visit(ctx.packageName);
-        const to = ctx.To ? ctx.To[0] : "";
-        const moduleNames = this.mapVisit(ctx.moduleName);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        if (ctx.To) {
-            return group(rejectAndConcat([
-                indent(rejectAndJoin(line, [
-                    rejectAndJoin(" ", [ctx.Opens[0], packageName]),
-                    group(indent(rejectAndJoin(line, [
-                        ctx.To[0],
-                        rejectAndJoinSeps(commas, moduleNames)
-                    ])))
-                ])),
-                ctx.Semicolon[0]
-            ]));
+    },
+    packageModifier: printSingle,
+    importDeclaration(path, print) {
+        const { children } = path.node;
+        if (children.emptyStatement) {
+            return call(path, print, "emptyStatement");
+        }
+        const declaration = ["import "];
+        if (children.Static) {
+            declaration.push("static ");
+        }
+        declaration.push(call(path, print, "packageOrTypeName"));
+        if (children.Star) {
+            declaration.push(".*");
         }
-        return rejectAndConcat([
-            concat([ctx.Opens[0], " "]),
-            packageName,
-            ctx.Semicolon[0]
+        declaration.push(";");
+        return declaration;
+    },
+    typeDeclaration(path, print) {
+        return path.node.children.Semicolon ? "" : printSingle(path, print);
+    },
+    moduleDeclaration(path, print) {
+        const { annotation, Open } = path.node.children;
+        const prefix = [];
+        if (annotation) {
+            prefix.push(...map(path, print, "annotation"));
+        }
+        if (Open) {
+            prefix.push("open");
+        }
+        const declarations = map(path, declarationPath => {
+            const declaration = print(declarationPath);
+            const { node, previous } = declarationPath;
+            return !previous ||
+                lineStartWithComments(node) <= lineEndWithComments(previous) + 1
+                ? declaration
+                : [hardline, declaration];
+        }, "moduleDirective");
+        return join(" ", [
+            ...prefix,
+            "module",
+            printName(path, print),
+            printBlock(path, declarations)
         ]);
-    }
-    usesModuleDirective(ctx) {
-        const typeName = this.visit(ctx.typeName);
-        return rejectAndConcat([
-            concat([ctx.Uses[0], " "]),
-            typeName,
-            ctx.Semicolon[0]
+    },
+    moduleDirective: printSingle,
+    requiresModuleDirective(path, print) {
+        return join(" ", [
+            "requires",
+            ...map(path, print, "requiresModifier"),
+            [call(path, print, "moduleName"), ";"]
         ]);
-    }
-    providesModuleDirective(ctx) {
-        const firstTypeName = this.visit(ctx.typeName[0]);
-        const otherTypeNames = this.mapVisit(ctx.typeName.slice(1));
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndConcat([
-            indent(rejectAndJoin(line, [
-                rejectAndJoin(" ", [ctx.Provides[0], firstTypeName]),
-                group(indent(rejectAndJoin(line, [
-                    ctx.With[0],
-                    rejectAndJoinSeps(commas, otherTypeNames)
-                ])))
+    },
+    exportsModuleDirective(path, print) {
+        return printToModuleNamesDirective(path, print, "exports");
+    },
+    opensModuleDirective(path, print) {
+        return printToModuleNamesDirective(path, print, "opens");
+    },
+    usesModuleDirective(path, print) {
+        return ["uses ", call(path, print, "typeName"), ";"];
+    },
+    providesModuleDirective(path, print) {
+        const [firstTypeName, ...restTypeNames] = map(path, print, "typeName");
+        return [
+            "provides ",
+            firstTypeName,
+            group(indent([
+                line,
+                group(indent(["with", line, ...join([",", line], restTypeNames)]))
             ])),
-            ctx.Semicolon[0]
-        ]));
+            ";"
+        ];
+    },
+    requiresModifier: printSingle
+};
+function sortImports(importDeclarations) {
+    importDeclarations.sort(({ children: a }, { children: b }) => {
+        if (a.Static && !b.Static) {
+            return -1;
+        }
+        else if (b.Static && !a.Static) {
+            return 1;
+        }
+        if (!b.packageOrTypeName) {
+            if (a.packageOrTypeName) {
+                return -1;
+            }
+            return 0;
+        }
+        else if (!a.packageOrTypeName) {
+            return 1;
+        }
+        return compareFqn(a.packageOrTypeName[0], b.packageOrTypeName[0]);
+    });
+    return importDeclarations.reduce((staticCount, importDeclaration) => importDeclaration.children.Static ? staticCount + 1 : staticCount, 0);
+}
+function compareFqn(a, b) {
+    const identifiersA = a.children.Identifier;
+    const identifiersB = b.children.Identifier;
+    const minParts = Math.min(identifiersA.length, identifiersB.length);
+    for (let i = 0; i < minParts; i++) {
+        const imageA = identifiersA[i].image;
+        const imageB = identifiersB[i].image;
+        if (imageA < imageB) {
+            return -1;
+        }
+        else if (imageA > imageB) {
+            return 1;
+        }
     }
-    requiresModifier(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
+    return identifiersA.length - identifiersB.length;
+}
+function printToModuleNamesDirective(path, print, prefix) {
+    const directive = [prefix, " ", call(path, print, "packageName")];
+    if (path.node.children.moduleName) {
+        const moduleNames = join([",", line], map(path, print, "moduleName"));
+        directive.push(group(indent([line, group(indent(["to", line, ...moduleNames]))])));
     }
+    directive.push(";");
+    return directive;
 }

package/dist/printers/types-values-and-variables.d.ts

@@ -0,0 +1,46 @@
+import { builders } from "prettier/doc";
+import { printClassType, printSingle } from "./helpers.js";
+declare const _default: {
+    primitiveType(path: import("prettier").AstPath<import("../../../java-parser/api.js").PrimitiveTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    numericType: typeof printSingle;
+    integralType: typeof printSingle;
+    floatingPointType: typeof printSingle;
+    referenceType(path: import("prettier").AstPath<import("../../../java-parser/api.js").ReferenceTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    classOrInterfaceType: typeof printSingle;
+    classType: typeof printClassType;
+    interfaceType: typeof printSingle;
+    typeVariable(path: import("prettier").AstPath<import("../../../java-parser/api.js").TypeVariableCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    dims(path: import("prettier").AstPath<import("../../../java-parser/api.js").DimsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeParameter(path: import("prettier").AstPath<import("../../../java-parser/api.js").TypeParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeParameterModifier: typeof printSingle;
+    typeBound(path: import("prettier").AstPath<import("../../../java-parser/api.js").TypeBoundCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    additionalBound(path: import("prettier").AstPath<import("../../../java-parser/api.js").AdditionalBoundCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeArguments(path: import("prettier").AstPath<import("../../../java-parser/api.js").TypeArgumentsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    typeArgumentList(path: import("prettier").AstPath<import("../../../java-parser/api.js").TypeArgumentListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeArgument: typeof printSingle;
+    wildcard(path: import("prettier").AstPath<import("../../../java-parser/api.js").WildcardCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    wildcardBounds(path: import("prettier").AstPath<import("../../../java-parser/api.js").WildcardBoundsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+};
+export default _default;

package/dist/printers/types-values-and-variables.js

@@ -1,153 +1,90 @@
-import forEach from "lodash/forEach.js";
 import { builders } from "prettier/doc";
-import { concat, group, indent, join } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortClassTypeChildren } from "./printer-utils.js";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-import { isAnnotationCstNode, isCstNode, isTypeArgumentsCstNode } from "../types/utils.js";
-const { line, softline } = builders;
-export class TypesValuesAndVariablesPrettierVisitor extends BaseCstPrettierPrinter {
-    primitiveType(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const type = ctx.numericType
-            ? this.visit(ctx.numericType)
-            : this.getSingle(ctx);
-        return rejectAndJoin(" ", [join(" ", annotations), type]);
-    }
-    numericType(ctx) {
-        return this.visitSingle(ctx);
-    }
-    integralType(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    floatingPointType(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    referenceType(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const type = ctx.primitiveType
-            ? this.visit(ctx.primitiveType)
-            : this.visit(ctx.classOrInterfaceType);
-        const dims = this.visit(ctx.dims);
-        return rejectAndJoin(" ", [join(" ", annotations), concat([type, dims])]);
-    }
-    classOrInterfaceType(ctx) {
-        return this.visitSingle(ctx);
-    }
-    classType(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]), " ");
-            }
-            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);
-    }
-    interfaceType(ctx) {
-        return this.visitSingle(ctx);
-    }
-    typeVariable(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const identifier = this.getSingle(ctx);
-        return rejectAndJoin(" ", [join(" ", annotations), identifier]);
-    }
-    dims(ctx) {
-        let tokens = [...ctx.LSquare];
-        if (ctx.annotation) {
-            tokens = [...tokens, ...ctx.annotation];
-        }
-        tokens = tokens.sort((a, b) => {
-            const startOffset1 = isCstNode(a)
-                ? a.children.At[0].startOffset
-                : a.startOffset;
-            const startOffset2 = isCstNode(b)
-                ? b.children.At[0].startOffset
-                : b.startOffset;
-            return startOffset1 - startOffset2;
-        });
-        const segments = [];
-        let currentSegment = [];
-        forEach(tokens, token => {
-            if (isCstNode(token)) {
-                currentSegment.push(this.visit([token]));
-            }
-            else {
-                segments.push(rejectAndConcat([
-                    rejectAndJoin(" ", currentSegment),
-                    concat([ctx.LSquare[0], ctx.RSquare[0]])
-                ]));
-                currentSegment = [];
-            }
-        });
-        return rejectAndConcat(segments);
-    }
-    typeParameter(ctx) {
-        const typeParameterModifiers = this.mapVisit(ctx.typeParameterModifier);
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const typeBound = this.visit(ctx.typeBound);
-        return rejectAndJoin(" ", [
-            join(" ", typeParameterModifiers),
-            typeIdentifier,
-            typeBound
+import { call, definedKeys, flatMap, isNonTerminal, map, onlyDefinedKey, printClassType, printList, printSingle } from "./helpers.js";
+const { group, indent, join, line, softline } = builders;
+export default {
+    primitiveType(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, ["Boolean", "numericType"]);
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, typeKey)
         ]);
-    }
-    typeParameterModifier(ctx) {
-        return this.visitSingle(ctx);
-    }
-    typeBound(ctx) {
-        const classOrInterfaceType = this.visit(ctx.classOrInterfaceType);
-        const additionalBound = this.mapVisit(ctx.additionalBound);
-        return concat([
-            rejectAndJoin(" ", [ctx.Extends[0], classOrInterfaceType]),
-            indent(group(concat([
-                additionalBound.length ? line : "",
-                rejectAndJoin(line, additionalBound)
-            ])))
+    },
+    numericType: printSingle,
+    integralType: printSingle,
+    floatingPointType: printSingle,
+    referenceType(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, [
+            "primitiveType",
+            "classOrInterfaceType"
         ]);
-    }
-    additionalBound(ctx) {
-        const interfaceType = this.visit(ctx.interfaceType);
-        return join(" ", [ctx.And[0], interfaceType]);
-    }
-    typeArguments(ctx) {
-        const typeArgumentList = this.visit(ctx.typeArgumentList);
-        return putIntoBraces(typeArgumentList, softline, ctx.Less[0], ctx.Greater[0]);
-    }
-    typeArgumentList(ctx) {
-        const typeArguments = this.mapVisit(ctx.typeArgument);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return rejectAndJoinSeps(commas, typeArguments);
-    }
-    typeArgument(ctx) {
-        return this.visitSingle(ctx);
-    }
-    wildcard(ctx) {
-        const annotations = this.mapVisit(ctx.annotation);
-        const wildcardBounds = this.visit(ctx.wildcardBounds);
-        return rejectAndJoin(" ", [
-            join(" ", annotations),
-            ctx.QuestionMark[0],
-            wildcardBounds
+        const type = call(path, print, typeKey);
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            children.dims ? [type, call(path, print, "dims")] : type
         ]);
-    }
-    wildcardBounds(ctx) {
-        const keyWord = ctx.Extends ? ctx.Extends[0] : ctx.Super[0];
-        const referenceType = this.visit(ctx.referenceType);
-        return join(" ", [keyWord, referenceType]);
-    }
-}
+    },
+    classOrInterfaceType: printSingle,
+    classType: printClassType,
+    interfaceType: printSingle,
+    typeVariable(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "Identifier")
+        ]);
+    },
+    dims(path, print) {
+        return flatMap(path, childPath => {
+            const child = print(childPath);
+            return isNonTerminal(childPath.node) ? [child, " "] : child;
+        }, definedKeys(path.node.children, ["annotation", "LSquare", "RSquare"]));
+    },
+    typeParameter(path, print) {
+        const parameter = [
+            ...map(path, print, "typeParameterModifier"),
+            call(path, print, "typeIdentifier")
+        ];
+        if (path.node.children.typeBound) {
+            parameter.push(call(path, print, "typeBound"));
+        }
+        return join(" ", parameter);
+    },
+    typeParameterModifier: printSingle,
+    typeBound(path, print) {
+        const bound = ["extends ", call(path, print, "classOrInterfaceType")];
+        if (path.node.children.additionalBound) {
+            bound.push(group(indent([line, ...join(line, map(path, print, "additionalBound"))])));
+        }
+        return bound;
+    },
+    additionalBound(path, print) {
+        return ["& ", call(path, print, "interfaceType")];
+    },
+    typeArguments(path, print) {
+        return group([
+            "<",
+            indent([softline, call(path, print, "typeArgumentList")]),
+            softline,
+            ">"
+        ]);
+    },
+    typeArgumentList(path, print) {
+        return printList(path, print, "typeArgument");
+    },
+    typeArgument: printSingle,
+    wildcard(path, print) {
+        const wildcard = [...map(path, print, "annotation"), "?"];
+        if (path.node.children.wildcardBounds) {
+            wildcard.push(call(path, print, "wildcardBounds"));
+        }
+        return join(" ", wildcard);
+    },
+    wildcardBounds(path, print) {
+        return [
+            path.node.children.Extends ? "extends" : "super",
+            " ",
+            call(path, print, "referenceType")
+        ];
+    }
+};

package/package.json

@@ -1,22 +1,20 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.6.8",
+  "version": "2.7.0",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": {
-    "types": "./index.d.ts",
+    "types": "./dist/index.d.ts",
     "default": "./dist/index.js"
   },
   "files": [
-    "dist",
-    "index.d.ts"
+    "dist"
   ],
   "homepage": "https://jhipster.github.io/prettier-java/",
   "repository": "https://github.com/jhipster/prettier-java",
   "license": "Apache-2.0",
   "dependencies": {
-    "java-parser": "2.3.4",
-    "lodash": "4.17.21"
+    "java-parser": "3.0.0"
   },
   "scripts": {
     "test": "yarn run test:unit && yarn run test:e2e-core",
@@ -35,7 +33,6 @@
     "@types/fs-extra": "11.0.4",
     "@types/jest": "29.5.14",
     "@types/klaw-sync": "6.0.5",
-    "@types/lodash": "4.17.13",
     "@types/node": "18.19.64",
     "@types/sinon": "17.0.3",
     "ts-node": "10.9.2",
@@ -44,5 +41,5 @@
   "peerDependencies": {
     "prettier": "^3.0.0"
   },
-  "gitHead": "a1b05b474a157165133bff7a86c1d2b88bbfa5b4"
+  "gitHead": "593b07bbefbda0141f3816b8e0cf24af91a987fb"
 }