prettier-plugin-java 2.6.3 → 2.6.5

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

@@ -0,0 +1,153 @@
+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
+        ]);
+    }
+    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)
+            ])))
+        ]);
+    }
+    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
+        ]);
+    }
+    wildcardBounds(ctx) {
+        const keyWord = ctx.Extends ? ctx.Extends[0] : ctx.Super[0];
+        const referenceType = this.visit(ctx.referenceType);
+        return join(" ", [keyWord, referenceType]);
+    }
+}

package/dist/types/utils.js

@@ -0,0 +1,20 @@
+export function isCstNode(tokenOrNode) {
+    return !isIToken(tokenOrNode);
+}
+export function isIToken(tokenOrNode) {
+    return (tokenOrNode.tokenType !== undefined &&
+        tokenOrNode.image !== undefined);
+}
+export function isCstElementOrUndefinedIToken(tokenOrNode) {
+    return tokenOrNode !== undefined && isIToken(tokenOrNode);
+}
+export const isTypeArgumentsCstNode = (cstElement) => {
+    return cstElement.name === "typeArguments";
+};
+export const isAnnotationCstNode = (cstElement) => {
+    return cstElement.name === "annotation";
+};
+export const isOrdinaryCompilationUnitCtx = (ctx) => {
+    return (ctx.ordinaryCompilationUnit !==
+        undefined);
+};

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export { default as printArgumentListWithBraces } from "./printArgumentListWithBraces.js";
+export { default as isEmptyDoc } from "./isEmptyDoc.js";

package/dist/utils/isEmptyDoc.js

@@ -0,0 +1,4 @@
+const isEmptyDoc = (argument) => {
+    return argument === "" || (Array.isArray(argument) && argument.length) === 0;
+};
+export default isEmptyDoc;

package/dist/utils/printArgumentListWithBraces.js

@@ -0,0 +1,37 @@
+import { builders } from "prettier/doc";
+import { handleCommentsParameters } from "../printers/comments/handle-comments.js";
+import { indent } from "../printers/prettier-builder.js";
+import { rejectAndConcat } from "../printers/printer-utils.js";
+const { lineSuffixBoundary, softline } = builders;
+export default function printArgumentListWithBraces(argumentListNodes, rBrace, lBrace) {
+    var _a, _b, _c;
+    const argumentListNode = argumentListNodes === null || argumentListNodes === void 0 ? void 0 : argumentListNodes[0];
+    const expressions = (_a = argumentListNode === null || argumentListNode === void 0 ? void 0 : argumentListNode.children.expression) !== null && _a !== void 0 ? _a : [];
+    if (argumentListNode) {
+        const { leadingComments, trailingComments } = argumentListNode;
+        delete argumentListNode.leadingComments;
+        delete argumentListNode.trailingComments;
+        if (leadingComments) {
+            const firstExpression = expressions[0];
+            firstExpression.leadingComments = [
+                ...leadingComments,
+                ...((_b = firstExpression.leadingComments) !== null && _b !== void 0 ? _b : [])
+            ];
+        }
+        if (trailingComments) {
+            const lastExpression = expressions.at(-1);
+            lastExpression.trailingComments = [
+                ...((_c = lastExpression.trailingComments) !== null && _c !== void 0 ? _c : []),
+                ...trailingComments
+            ];
+        }
+    }
+    handleCommentsParameters(lBrace, expressions, rBrace);
+    const argumentList = this.visit(argumentListNodes);
+    const contents = argumentList
+        ? [argumentList]
+        : lBrace.trailingComments
+            ? [softline, lineSuffixBoundary]
+            : [];
+    return rejectAndConcat([indent(lBrace), ...contents, rBrace]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-java",
-  "version": "2.6.3",
+  "version": "2.6.5",
   "description": "Prettier Java Plugin",
   "type": "module",
   "exports": "./dist/index.js",
@@ -38,5 +38,5 @@
     "ts-node": "10.9.1",
     "typescript": "4.9.3"
   },
-  "gitHead": "0a7a02e6a8f2a9b5893a41395ebc85e4bcac8a66"
+  "gitHead": "1c4691a0b302c4cceed4b30d8266d3235fca2de8"
 }