@haneullabs/prettier-plugin-move 0.3.3

package/src/utilities.ts

@@ -0,0 +1,387 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '.';
+import { AstPath, Doc, ParserOptions, doc } from 'prettier';
+import { MoveOptions, printFn } from './printer';
+
+const {
+    indent,
+    join,
+    fill,
+    softline,
+    dedent,
+    hardline,
+    line,
+    lineSuffix,
+    group,
+    indentIfBreak,
+    hardlineWithoutBreakParent,
+    breakParent,
+    ifBreak,
+} = doc.builders;
+
+/**
+ * Prints an `identifier` node.
+ */
+export function printIdentifier(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+
+/**
+ * Returns `true` if the first non-formatting child of the path starts on a new line.
+ * This function is useful for respecting developer formatting if they choose to break
+ * the list.
+ *
+ * ```move
+ * // input
+ * fun args(a: u8) {} // no break
+ * fun args(
+ *   a: u8 // first child starts on a new line
+ * ) {}
+ *
+ * // output
+ * fun args(a: u8) {} // no break
+ * fun args(
+ *  a: u8 // respect developer formatting
+ * ) {}
+ * ```
+ *
+ * @param path
+ * @returns
+ */
+export function shouldBreakFirstChild(path: AstPath<Node>): boolean {
+    return path.node.nonFormattingChildren[0]?.startsOnNewLine || false;
+}
+
+/**
+ * Prints all comments that are leading the node. This function is injected into
+ * the `printFn` to print comments before the node. See the `print` function in
+ * `printer.ts` for more information.
+ *
+ * @param path
+ * @returns
+ */
+export function printLeadingComment(path: AstPath<Node>, options: MoveOptions): Doc[] {
+    const comments = path.node.leadingComment;
+    if (!comments || !comments.length) return [];
+    if (!path.node.enableLeadingComment) return [];
+
+    if (comments.length == 1 && comments[0]!.type == 'block_comment') {
+        return [comments[0]!.text, comments[0]!.newline ? hardlineWithoutBreakParent : ' '];
+    }
+
+    if (options.wrapComments == false) {
+        return [
+            join(
+                hardlineWithoutBreakParent,
+                comments.map((c) =>
+                    c.type == 'line_comment' ? [c.text, /* used to be breakParent */ ''] : [c.text],
+                ),
+            ),
+            hardlineWithoutBreakParent,
+        ];
+    }
+
+    // we do not concatenate the comments into a single string, and treat each
+    // line separately.
+    return comments.map((comment) => {
+        if (comment.type == 'line_comment') {
+            const isDoc = comment.text.startsWith('///');
+            const parts = comment.text.slice(isDoc ? 4 : 3).split(' ');
+
+            return [
+                isDoc ? '/// ' : '// ',
+                fill(join(ifBreak([softline, isDoc ? '/// ' : '// '], ' '), parts)),
+                hardlineWithoutBreakParent,
+            ];
+        }
+
+        return comment.text;
+    });
+}
+
+/**
+ * Prints the trailing comments of the node. Currently, we only allow a single line
+ * comment to be printed. This function is injected into the `printFn` to print
+ * comments after the node. See the `print` function in `printer.ts` for more information.
+ *
+ * @param path
+ * @returns
+ */
+export function printTrailingComment(path: AstPath<Node>, shouldBreak: boolean = false): Doc {
+    // we do not allow comments on empty lines
+    if (path.node.isEmptyLine) return '';
+    if (!path.node.enableTrailingComment) return '';
+    const comment = path.node.trailingComment;
+    if (!comment) return '';
+    if (comment.type == 'line_comment' && shouldBreak) {
+        return [' ', comment.text, hardline];
+    }
+
+    return [' ', comment.text];
+}
+
+export function emptyBlockOrList(
+    path: AstPath<Node>,
+    open: string,
+    close: string,
+    line: Doc = hardline,
+): Doc {
+    const length = path.node.nonFormattingChildren.length;
+    const comments = path.node.namedChildren.filter((e) => e.isComment);
+
+    if (length != 0) {
+        throw new Error('The list is not empty');
+    }
+
+    if (comments.length == 0) {
+        return [open, close];
+    }
+
+    if (comments.length == 1 && comments[0]!.type == 'block_comment') {
+        return group([open, indent(line), indent(comments[0]!.text), line, close]);
+    }
+
+    return group(
+        [
+            open,
+            indent(line),
+            indent(
+                join(
+                    line,
+                    comments.map((c) => c.text),
+                ),
+            ),
+            line,
+            close,
+        ],
+        { shouldBreak: true },
+    );
+}
+
+/**
+ * TODO: use this type for the `block()` function.
+ */
+export type BlockOptions = {
+    path: AstPath<Node>;
+    print: printFn;
+    options: ParserOptions;
+    breakDependency?: Symbol;
+
+    lastLine?: boolean;
+    lineEnding?: Doc;
+    skipChildren?: number;
+    shouldBreak?: boolean;
+};
+
+/**
+ */
+export function block({ path, print, options, shouldBreak, skipChildren }: BlockOptions) {
+    const length = path.node.nonFormattingChildren.length;
+
+    if (length == 0) {
+        return emptyBlockOrList(path, '{', '}', hardline);
+    }
+
+    return group(
+        [
+            '{',
+            options.bracketSpacing ? ifBreak('', ' ') : '',
+            indent(softline),
+            indent(join(line, path.map(print, 'namedAndEmptyLineChildren').slice(skipChildren))),
+            softline,
+            options.bracketSpacing ? ifBreak('', ' ') : '',
+            '}',
+        ],
+        { shouldBreak },
+    );
+}
+
+export function nonBreakingBlock({
+    path,
+    print,
+    options,
+    shouldBreak, // always breaks
+    skipChildren,
+}: BlockOptions) {
+    const length = path.node.nonFormattingChildren.length;
+
+    if (length == 0) {
+        return emptyBlockOrList(path, '{', '}', hardlineWithoutBreakParent);
+    }
+
+    return group([
+        '{',
+        indent(hardlineWithoutBreakParent),
+        indent(
+            join(
+                hardlineWithoutBreakParent,
+                path.map(print, 'namedAndEmptyLineChildren').slice(skipChildren || 0),
+            ),
+        ),
+        hardlineWithoutBreakParent,
+        '}',
+    ]);
+}
+
+export type ListOptions = {
+    path: AstPath<Node>;
+    print: printFn;
+    options: MoveOptions;
+    /** Opening bracket. */
+    open: string;
+    /** Closing bracket. */
+    close: string;
+    /**
+     * The number of children to skip when printing the list.
+     */
+    skipChildren?: number;
+    /**
+     * Whether to add a whitespace after the open bracket and before the close bracket.
+     * ```
+     * { a, b, c } // addWhitespace = true
+     * {a, b, c}   // addWhitespace = false
+     * ```
+     */
+    addWhitespace?: boolean;
+    /**
+     * Whether to break the list.
+     */
+    shouldBreak?: boolean;
+    /**
+     * Group ID for `indentIfBreak` to break the list.
+     */
+    indentGroup?: symbol | null;
+};
+
+/**
+ * Prints a list of non-formatting children. Handles commas and trailing comments.
+ * TODO: keep trailing comments after the last element of the list.
+ */
+export function list({
+    path,
+    print,
+    options,
+    open,
+    close,
+    indentGroup = null,
+    addWhitespace = false,
+    skipChildren = 0,
+    shouldBreak = false,
+}: ListOptions) {
+    const length = path.node.nonFormattingChildren.length;
+    const indentCb: (el: Doc) => Doc = (el) =>
+        indentGroup ? indentIfBreak(el, { groupId: indentGroup }) : indent(el);
+
+    // if there's no children the list should print, we still look up for non-
+    // formatting nodes, namely comments, to print them.
+    if (length == skipChildren) {
+        const lastNode = path.node.nonFormattingChildren[length - 1]!;
+        const indexInNamedChildren = path.node.namedChildren.indexOf(lastNode);
+        const otherNamedChildren = path.node.namedChildren
+            .slice(indexInNamedChildren + 1)
+            .filter((e) => e.isComment);
+
+        if (!otherNamedChildren.length) {
+            return [open, close];
+        }
+
+        return [
+            open,
+            indentCb(softline),
+            indentCb(
+                join(
+                    hardline,
+                    otherNamedChildren.map((c) => c.text),
+                ),
+            ),
+            hardline,
+            dedent(close),
+        ];
+    }
+
+    const lastNode = path.node.nonFormattingChildren[length - 1]!;
+    const indexInNamedChildren = path.node.namedChildren.indexOf(lastNode);
+
+    // collect all trailing comments
+    // after `nonFormattingChildren` and before end
+    let trailingComments = [] as Doc[];
+    if (indexInNamedChildren != -1) {
+        path.each((path, idx) => {
+            if (idx + 1 > indexInNamedChildren && path.node.isComment) {
+                return trailingComments.push(path.node.text);
+            }
+            return;
+        }, 'namedChildren');
+    }
+
+    return [
+        open,
+        indentCb(addWhitespace ? line : softline),
+        shouldBreak ? breakParent : '',
+        indentCb(
+            path
+                .map((path, i) => {
+                    const leading = printLeadingComment(path, options);
+                    const comment = printTrailingComment(path, false);
+                    let shouldBreak = false;
+
+                    // if the node has a trailing comment, we should break
+                    if (path.node.trailingComment?.type == 'line_comment') {
+                        shouldBreak = true;
+                    }
+
+                    const leadComment = path.node.leadingComment;
+
+                    if (leadComment.length > 0 && leadComment![0]!.type == 'line_comment') {
+                        shouldBreak = true;
+                    }
+
+                    if (
+                        leadComment.length > 0 &&
+                        leadComment[0]!.type == 'block_comment' &&
+                        leadComment[0]!.newline
+                    ) {
+                        shouldBreak = true;
+                    }
+
+                    path.node.disableTrailingComment();
+                    path.node.disableLeadingComment();
+
+                    const breakExpr = shouldBreak ? breakParent : '';
+                    const shouldDedent = trailingComments.length == 0;
+                    const endingExpr = addWhitespace ? line : softline;
+                    const isLastChild = i == length - 1;
+
+                    if (isLastChild) {
+                        return [
+                            leading,
+                            breakExpr,
+                            print(path),
+                            ifBreak(','),
+                            shouldBreak ? lineSuffix(comment) : comment,
+                            shouldDedent ? dedent(endingExpr) : endingExpr,
+                        ];
+                    }
+
+                    // if we are not at the last child, add a comma
+                    return [
+                        leading,
+                        breakExpr,
+                        print(path),
+                        ',',
+                        shouldBreak ? lineSuffix(comment) : comment,
+                        line,
+                    ];
+                }, 'nonFormattingChildren')
+                .slice(skipChildren)
+                .concat(
+                    trailingComments.length
+                        ? [join(hardline, trailingComments), dedent(hardline)]
+                        : [],
+                ),
+        ),
+        dedent(close),
+    ];
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"module": "CommonJS",
+		"target": "es2021",
+		"outDir": "out",
+		"lib": ["es2021"],
+		"sourceMap": true,
+		"rootDir": "src",
+		"newLine": "LF",
+		"strict": true,
+		"allowUnreachableCode": false,
+		"allowUnusedLabels": false,
+		"exactOptionalPropertyTypes": true,
+		"noFallthroughCasesInSwitch": true,
+		"noImplicitAny": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noImplicitThis": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"noUncheckedIndexedAccess": true,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false
+	},
+	"exclude": ["node_modules", "out"],
+	"include": ["src"]
+}