@haneullabs/prettier-plugin-move 0.3.3

package/src/cst/expression/match_expression.ts

@@ -0,0 +1,102 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc } from 'prettier';
+import { list } from '../../utilities';
+import { builders } from 'prettier/doc';
+const { join, indent, group, softline, line } = builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'match_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printMatchExpression;
+    } else if (path.node.type === 'match_arm') {
+        return printMatchArm;
+    } else if (path.node.type === 'match_condition') {
+        return printMatchCondition;
+    }
+
+    return null;
+}
+
+/**
+ * Print `match_expression` node.
+ * Inside:
+ * - `match`
+ * - `(`
+ * - `_expression`
+ * - `)`
+ * - `_match_body`
+ */
+function printMatchExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const condNode = path.node.nonFormattingChildren[0]!;
+    const parts: Doc[] = ['match '];
+
+    if (condNode.isBreakableExpression) {
+        parts.push('(', path.call(print, 'nonFormattingChildren', 0), ')');
+    } else {
+        parts.push(
+            group([
+                '(',
+                indent(softline),
+                indent(path.call(print, 'nonFormattingChildren', 0)),
+                softline,
+                ')',
+            ]),
+        );
+    }
+
+    parts.push(
+        ' ',
+        list({
+            path,
+            print,
+            options,
+            open: '{',
+            close: '}',
+            skipChildren: 1,
+            shouldBreak: true,
+        }),
+    );
+
+    return parts;
+}
+
+/**
+ * Print `match_arm` node.
+ */
+function printMatchArm(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const children = path.map(print, 'nonFormattingChildren');
+
+    if (children.length < 2) {
+        throw new Error('`match_arm` node should have at least 2 children');
+    }
+
+    if (children.length == 2) {
+        return group(join(' => ', children));
+    }
+
+    if (children.length == 3) {
+        return [children[0]!, ' ', children[1]!, group([' =>', indent(line), children[2]!])];
+    }
+
+    throw new Error('`match_arm` node should have at most 3 children');
+}
+
+/**
+ * Prints `match_condition` node in `match_arm`.
+ * Example: `Enum if (x == 1) => 1,`, `if (...)` here is a `match_condition` node.
+ */
+function printMatchCondition(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const children = path.node.nonFormattingChildren;
+
+    if (children.length !== 1) {
+        throw new Error('`match_condition` expects 1 child');
+    }
+
+    return ['if (', path.call(print, 'nonFormattingChildren', 0), ')'];
+}

package/src/cst/expression/move_or_copy_expression.ts

@@ -0,0 +1,29 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const {} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'move_or_copy_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printMoveOrCopyExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `move_or_copy_expression` node.
+ */
+function printMoveOrCopyExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const ref = path.node.child(0)!.text == 'move' ? ['move', ' '] : ['copy', ' '];
+    return [
+        ...ref,
+        path.call(print, 'nonFormattingChildren', 0), // expression
+    ];
+}

package/src/cst/expression/name_expression.ts

@@ -0,0 +1,28 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const {} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'name_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printNameExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `name_expression` node.
+ * Inside:
+ * - `module_access`
+ * - `type_arguments`
+ */
+function printNameExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return path.map(print, 'nonFormattingChildren');
+}

package/src/cst/expression/pack_expression.ts

@@ -0,0 +1,29 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const {} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'pack_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printPackExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `pack_expression` node.
+ * Inside:
+ * - `module_access`
+ * - `type_arguments` (optional)
+ * - `field_initialize_list`
+ */
+function printPackExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return path.map(print, 'nonFormattingChildren');
+}

package/src/cst/expression/return_expression.ts

@@ -0,0 +1,50 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const { join, indent } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'return_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printReturnExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `return_expression` node.
+ */
+function printReturnExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const nodes = path.node.nonFormattingChildren;
+
+    if (nodes.length === 0) {
+        return 'return';
+    }
+
+    // either label or expression
+    if (nodes.length === 1) {
+        const expression = nodes[0]!;
+        const printed = path.call(print, 'nonFormattingChildren', 0);
+        return ['return ', expression.isBreakableExpression ? printed : indent(printed)];
+    }
+
+    // labeled expression
+    if (nodes.length === 2) {
+        const expression = nodes[1]!;
+        const printedLabel = path.call(print, 'nonFormattingChildren', 0);
+        const printedExpression = path.call(print, 'nonFormattingChildren', 1);
+        return join(' ', [
+            'return',
+            printedLabel,
+            expression.isBreakableExpression ? printedExpression : indent(printedExpression),
+        ]);
+    }
+
+    throw new Error('Invalid return expression');
+}

package/src/cst/expression/unary_expression.ts

@@ -0,0 +1,28 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const {} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'unary_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printUnaryExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `unary_expression` node.
+ */
+function printUnaryExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return [
+        path.call(print, 'nonFormattingChildren', 0),
+        path.call(print, 'nonFormattingChildren', 1),
+    ];
+}

package/src/cst/expression/unit_expression.ts

@@ -0,0 +1,18 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const {} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'unit_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return () => '()';
+    }
+
+    return null;
+}

package/src/cst/expression/vector_expression.ts

@@ -0,0 +1,97 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+import { list, printTrailingComment } from '../../utilities';
+import { printBreakableBlock } from './block';
+const { group, lineSuffix } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'vector_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printVectorExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `vector_expression` node.
+ */
+function printVectorExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.namedChildCount === 0) {
+        return 'vector[]';
+    }
+
+    // Injected print callback for elements in the vector
+    const printCb = (path: AstPath<Node>) => printElement(path, options, print);
+    const trailing = path.node.trailingComment;
+    let trailingComment: Doc = '';
+
+    if (trailing?.type === 'line_comment') {
+        trailingComment = printTrailingComment(path, false);
+        path.node.disableTrailingComment();
+    }
+
+    // Vector without type specified
+    // Eg: `vector[....]`
+    if (path.node.child(0)?.text == 'vector[') {
+        return group(
+            [
+                'vector',
+                list({ path, print: printCb, options, open: '[', close: ']' }) as Doc[],
+                lineSuffix(trailingComment),
+            ],
+            { shouldBreak: false },
+        );
+    }
+
+    if (!path.node.nonFormattingChildren[0]?.isTypeParam) {
+        throw new Error(
+            `Expected a type parameter in the \`vector_expression\`, got \`${path.node.nonFormattingChildren[0]?.type}\``,
+        );
+    }
+
+    if (path.node.nonFormattingChildren.slice(1).some((child) => child.isTypeParam)) {
+        throw new Error('Expected only one type parameter in the `vector_expression`');
+    }
+
+    // Vector with type
+    // Eg: `vector<TYPE>[...]`
+    return [
+        'vector<',
+        // do not break the type in vector literal
+        // indent(softline),
+        group(path.call(print, 'nonFormattingChildren', 0), { shouldBreak: false }),
+        '>',
+        group(
+            list({
+                path,
+                print: printCb,
+                options,
+                open: '[',
+                close: ']',
+                skipChildren: 1,
+                shouldBreak: false,
+            }) as Doc[],
+        ),
+        lineSuffix(trailingComment),
+    ];
+}
+
+/**
+ * Special print elements in the `vector_expression`.
+ *
+ * - we want to use breakable blocks for `block` nodes;
+ */
+function printElement(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.type === 'block') {
+        return printBreakableBlock(path, options, print);
+    }
+
+    return print(path);
+}

package/src/cst/expression/while_expression.ts

@@ -0,0 +1,45 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '../..';
+import { MoveOptions, printFn, treeFn } from '../../printer';
+import { AstPath, Doc, doc } from 'prettier';
+const { indent, softline, group } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'while_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printWhileExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `while_expression` node.
+ *
+ * ```
+ * // single line
+ * while (bool_expr) expr
+ *
+ * // break condition
+ * while (
+ *	  very_long_expr &&
+ *	  very_long_expr
+ * ) {
+ *   expr;
+ * }
+ * ```
+ */
+function printWhileExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const condition = path.node.nonFormattingChildren[0]!.isList
+        ? [indent(softline), path.call(print, 'nonFormattingChildren', 0), softline]
+        : [indent(softline), indent(path.call(print, 'nonFormattingChildren', 0)), softline];
+
+    return [
+        ['while (', group(condition), ') '],
+        path.call(print, 'nonFormattingChildren', 1), // body
+    ];
+}

package/src/cst/formatting.ts

@@ -0,0 +1,100 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Node } from '..';
+import { treeFn } from '../printer';
+import { AstPath, Doc } from 'prettier';
+
+/**
+ * Creates a callback function to print commments and comment-related nodes.
+ *
+ * @param path
+ * @returns
+ */
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case Formatting.LineComment:
+            return printLineComment;
+        case Formatting.BlockComment:
+            return printBlockComment;
+        case Formatting.EmptyLine:
+            return printEmptyLine;
+        case Formatting.Newline:
+            return printNewline;
+        default:
+            return null;
+    }
+}
+
+export enum Formatting {
+    LineComment = 'line_comment',
+    BlockComment = 'block_comment',
+    /**
+     * Token that doesn't exist in the grammar but we insert it in
+     * the `Tree` representation of CST to represent an empty line.
+     */
+    EmptyLine = 'empty_line',
+    /**
+     * Special node to insert a newline before the next node.
+     * We use it to make a call to hardline or not.
+     */
+    Newline = 'newline',
+}
+
+export function startsOnNewLine(path: AstPath<Node>): boolean {
+    return path.previous?.type == Formatting.EmptyLine;
+}
+
+export function shouldNewLine(path: AstPath<Node>): boolean {
+    return path.node.nextNamedSibling?.type == Formatting.Newline;
+}
+
+/**
+ * Test if a node is a formatting node.
+ *
+ * @param node
+ * @returns
+ */
+export function isFormatting(node: Node): boolean {
+    return [
+        Formatting.LineComment,
+        Formatting.BlockComment,
+        Formatting.EmptyLine,
+        Formatting.Newline,
+    ].includes(node.type as Formatting);
+}
+
+export function isComment(node: Node | null): boolean {
+    return [Formatting.LineComment, Formatting.BlockComment].includes(node?.type as Formatting);
+}
+
+export function isEmptyLine(node: Node | null): boolean {
+    return Formatting.EmptyLine == node?.type;
+}
+
+export function isNewline(node: Node | null): boolean {
+    return Formatting.Newline == node?.type;
+}
+
+/**
+ * Print `line_comment` node.
+ * Comments are handled via the `addLeadingComments` function.
+ */
+export function printLineComment(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+
+/**
+ * Print `block_comment` node.
+ */
+export function printBlockComment(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+
+export function printEmptyLine(path: AstPath<Node>): Doc {
+    return ''; // should not be printed directly, used in `join(hardline)` to act as an extra newline
+}
+
+export function printNewline(path: AstPath<Node>): Doc {
+    return ''; // should not be printed, ever
+}