prettier-plugin-java 2.6.3 → 2.6.5

package/dist/printers/comments/comments-utils.js

@@ -0,0 +1,21 @@
+export function hasLeadingComments(token) {
+    return token.leadingComments !== undefined;
+}
+export function hasTrailingComments(token) {
+    return token.trailingComments !== undefined;
+}
+export function hasLeadingLineComments(token) {
+    return (token.leadingComments !== undefined &&
+        token.leadingComments.length !== 0 &&
+        token.leadingComments[token.leadingComments.length - 1].tokenType.name ===
+            "LineComment");
+}
+export function hasTrailingLineComments(token) {
+    return (token.trailingComments !== undefined &&
+        token.trailingComments.length !== 0 &&
+        token.trailingComments[token.trailingComments.length - 1].tokenType.name ===
+            "LineComment");
+}
+export function hasComments(token) {
+    return hasLeadingComments(token) || hasTrailingComments(token);
+}

package/dist/printers/comments/format-comments.js

@@ -0,0 +1,171 @@
+import { builders } from "prettier/doc";
+import { isCstElementOrUndefinedIToken } from "../../types/utils.js";
+import { doc } from "prettier";
+import isEmptyDoc from "../../utils/isEmptyDoc.js";
+const { hardline, lineSuffix, breakParent, literalline } = builders;
+/**
+ * Takes a token and return a doc with:
+ * - concatenated leading comments
+ * - the token image
+ * - concatenated trailing comments
+ *
+ * @param {IToken} token
+ * @return a doc with the token and its comments
+ */
+export function printTokenWithComments(token) {
+    return printWithComments(token, token.image.includes("\n")
+        ? doc.utils.replaceEndOfLine(token.image)
+        : token.image, getTokenLeadingComments, getTokenTrailingComments);
+}
+/**
+ * Takes a node and return a doc with:
+ * - concatenated leading comments
+ * - the node doc value
+ * - concatenated trailing comments
+ *
+ * @param {CstNode} node
+ * @param {Doc} value - the converted node value
+ * @return a doc with the token and its comments
+ */
+export function printNodeWithComments(node, value) {
+    return printWithComments(node, value, getNodeLeadingComments, getNodeTrailingComments);
+}
+function printWithComments(nodeOrToken, value, getLeadingComments, getTrailingComments) {
+    const leadingComments = getLeadingComments(nodeOrToken);
+    const trailingComments = getTrailingComments(nodeOrToken, value);
+    return leadingComments.length === 0 && trailingComments.length === 0
+        ? value
+        : [...leadingComments, value, ...trailingComments];
+}
+/**
+ * @param {IToken} token
+ * @return an array containing processed leading comments and separators
+ */
+export function getTokenLeadingComments(token) {
+    return getLeadingComments(token, token);
+}
+/**
+ * @param {CstNode} node
+ * @return an array containing processed leading comments and separators
+ */
+function getNodeLeadingComments(node) {
+    return getLeadingComments(node, node.location);
+}
+function getLeadingComments(nodeOrToken, location) {
+    const arr = [];
+    if (nodeOrToken.leadingComments !== undefined) {
+        let previousEndLine = nodeOrToken.leadingComments[0].endLine;
+        let step;
+        arr.push(formatComment(nodeOrToken.leadingComments[0]));
+        for (let i = 1; i < nodeOrToken.leadingComments.length; i++) {
+            step = nodeOrToken.leadingComments[i].startLine - previousEndLine;
+            if (step === 1 ||
+                nodeOrToken.leadingComments[i].startOffset > location.startOffset) {
+                arr.push(hardline);
+            }
+            else if (step > 1) {
+                arr.push(hardline, hardline);
+            }
+            arr.push(formatComment(nodeOrToken.leadingComments[i]));
+            previousEndLine = nodeOrToken.leadingComments[i].endLine;
+        }
+        step = location.startLine - previousEndLine;
+        if (step === 1 ||
+            nodeOrToken.leadingComments[nodeOrToken.leadingComments.length - 1]
+                .startOffset > location.startOffset) {
+            arr.push(hardline);
+        }
+        else if (step > 1) {
+            arr.push(hardline, hardline);
+        }
+    }
+    return arr;
+}
+/**
+ * @param {IToken} token
+ * @return an array containing processed trailing comments and separators
+ */
+function getTokenTrailingComments(token) {
+    return getTrailingComments(token, token.image, token);
+}
+/**
+ * @param {CstNode} node
+ * @param {string} value
+ * @return an array containing processed trailing comments and separators
+ */
+function getNodeTrailingComments(node, value) {
+    return getTrailingComments(node, value, node.location);
+}
+function getTrailingComments(nodeOrToken, value, location) {
+    const arr = [];
+    let previousEndLine = location.endLine;
+    if (nodeOrToken.trailingComments !== undefined) {
+        nodeOrToken.trailingComments.forEach((comment, idx) => {
+            let separator = "";
+            if (comment.startLine !== previousEndLine) {
+                arr.push(hardline);
+            }
+            else if (!isEmptyDoc(value) && idx === 0) {
+                separator = " ";
+            }
+            if (comment.tokenType.name === "LineComment") {
+                arr.push(lineSuffix([separator, formatComment(comment), breakParent]));
+            }
+            else {
+                arr.push(formatComment(comment));
+            }
+            previousEndLine = comment.endLine;
+        });
+    }
+    return arr;
+}
+function isJavaDoc(comment, lines) {
+    let isJavaDoc = true;
+    if (comment.tokenType.name === "TraditionalComment" && lines.length > 1) {
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim().charAt(0) !== "*") {
+                isJavaDoc = false;
+                break;
+            }
+        }
+    }
+    else {
+        isJavaDoc = false;
+    }
+    return isJavaDoc;
+}
+function formatJavaDoc(lines) {
+    const res = [lines[0].trim()];
+    for (let i = 1; i < lines.length; i++) {
+        res.push(hardline);
+        res.push(" " + lines[i].trim());
+    }
+    return res;
+}
+function formatComment(comment) {
+    const res = [];
+    const lines = comment.image.split("\n");
+    if (isJavaDoc(comment, lines)) {
+        return formatJavaDoc(lines);
+    }
+    lines.forEach(line => {
+        res.push(line);
+        res.push(literalline);
+    });
+    res.pop();
+    return res;
+}
+export function processComments(docs) {
+    if (!Array.isArray(docs)) {
+        if (isCstElementOrUndefinedIToken(docs)) {
+            return printTokenWithComments(docs);
+        }
+        return docs;
+    }
+    return docs.map(elt => {
+        if (isCstElementOrUndefinedIToken(elt)) {
+            return printTokenWithComments(elt);
+        }
+        return elt;
+    });
+}

package/dist/printers/comments/handle-comments.js

@@ -0,0 +1,102 @@
+import { hasLeadingComments, hasTrailingComments } from "./comments-utils.js";
+export function handleCommentsBinaryExpression(ctx) {
+    moveOperatorLeadingCommentsToNextExpression(ctx);
+    moveExpressionTrailingCommentsToNextOperator(ctx);
+}
+export function handleCommentsParameters(lBrace, parameters, rBrace) {
+    var _a, _b, _c;
+    const lBraceTrailingComments = lBrace.trailingComments;
+    const firstParameter = parameters.at(0);
+    if (lBraceTrailingComments && firstParameter) {
+        delete lBrace.trailingComments;
+        firstParameter.leadingComments = [
+            ...lBraceTrailingComments,
+            ...((_a = firstParameter.leadingComments) !== null && _a !== void 0 ? _a : [])
+        ];
+    }
+    const lastParameter = parameters.at(-1);
+    const rBraceLeadingComments = rBrace.leadingComments;
+    if (rBraceLeadingComments) {
+        delete rBrace.leadingComments;
+        if (lastParameter) {
+            lastParameter.trailingComments = [
+                ...((_b = lastParameter.trailingComments) !== null && _b !== void 0 ? _b : []),
+                ...rBraceLeadingComments
+            ];
+        }
+        else {
+            lBrace.trailingComments = [
+                ...((_c = lBrace.trailingComments) !== null && _c !== void 0 ? _c : []),
+                ...rBraceLeadingComments
+            ];
+        }
+    }
+}
+function moveOperatorLeadingCommentsToNextExpression(ctx) {
+    var _a;
+    let unaryExpressionIndex = 1;
+    (_a = ctx.BinaryOperator) === null || _a === void 0 ? void 0 : _a.forEach(binaryOperator => {
+        if (hasLeadingComments(binaryOperator)) {
+            while (ctx.unaryExpression[unaryExpressionIndex].location.startOffset <
+                binaryOperator.endOffset) {
+                unaryExpressionIndex++;
+            }
+            // Adapt the position of the operator and its leading comments
+            const shiftUp = binaryOperator.leadingComments[0].startLine -
+                1 -
+                binaryOperator.startLine;
+            if (binaryOperator.startLine !==
+                ctx.unaryExpression[unaryExpressionIndex].location.startLine) {
+                binaryOperator.leadingComments.forEach(comment => {
+                    comment.startLine += 1;
+                    comment.endLine += 1;
+                });
+            }
+            binaryOperator.startLine += shiftUp;
+            binaryOperator.endLine += shiftUp;
+            // Move binaryOperator's leading comments to the following
+            // unaryExpression
+            ctx.unaryExpression[unaryExpressionIndex].leadingComments =
+                ctx.unaryExpression[unaryExpressionIndex].leadingComments || [];
+            ctx.unaryExpression[unaryExpressionIndex].leadingComments.unshift(...binaryOperator.leadingComments);
+            delete binaryOperator.leadingComments;
+        }
+    });
+}
+function moveExpressionTrailingCommentsToNextOperator(ctx) {
+    const binaryOperators = ctx.BinaryOperator;
+    let binaryOperatorIndex = 0;
+    if (binaryOperators === null || binaryOperators === void 0 ? void 0 : binaryOperators.length) {
+        ctx.unaryExpression.forEach(unaryExpression => {
+            var _a;
+            if (hasTrailingComments(unaryExpression)) {
+                while (binaryOperatorIndex < binaryOperators.length - 1 &&
+                    unaryExpression.location.endOffset &&
+                    binaryOperators[binaryOperatorIndex].startOffset <
+                        unaryExpression.location.endOffset) {
+                    binaryOperatorIndex++;
+                }
+                const binaryOperator = binaryOperators[binaryOperatorIndex];
+                // Adapt the position of the expression and its trailing comments
+                const shiftUp = unaryExpression.trailingComments[0].startLine -
+                    1 -
+                    unaryExpression.location.startLine;
+                if (unaryExpression.location.startLine !== binaryOperator.startLine) {
+                    unaryExpression.trailingComments.forEach(comment => {
+                        comment.startLine += 1;
+                        comment.endLine += 1;
+                    });
+                }
+                unaryExpression.location.startLine += shiftUp;
+                if (unaryExpression.location.endLine !== undefined) {
+                    unaryExpression.location.endLine += shiftUp;
+                }
+                // Move unaryExpression's trailing comments to the following
+                // binaryOperator
+                binaryOperator.trailingComments = (_a = binaryOperator.trailingComments) !== null && _a !== void 0 ? _a : [];
+                binaryOperator.trailingComments.unshift(...unaryExpression.trailingComments);
+                delete unaryExpression.trailingComments;
+            }
+        });
+    }
+}