@haneullabs/prettier-plugin-move 0.3.3

package/src/cst/expression/expression_list.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';
+import { list } from '../../utilities';
+const { group } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'expression_list';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printExpressionList;
+    }
+
+    return null;
+}
+
+/**
+ * Print `expression_list` node.
+ */
+function printExpressionList(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return group(list({ path, print, options, open: '(', close: ')' }), {
+        shouldBreak: false,
+    });
+}

package/src/cst/expression/identified_expression.ts

@@ -0,0 +1,30 @@
+// 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 = 'identified_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printIdentifiedExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `identified_expression` node.
+ * Also known as `label` in the grammar or `labeled_expression`.
+ */
+function printIdentifiedExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return [
+        path.call(print, 'nonFormattingChildren', 0), // identifier
+        ' ',
+        path.call(print, 'nonFormattingChildren', 1), // expression
+    ];
+}

package/src/cst/expression/if_expression.ts

@@ -0,0 +1,177 @@
+// 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 { printTrailingComment } from '../../utilities';
+const {
+    group,
+    softline,
+    line,
+    ifBreak,
+    indent,
+    lineSuffix,
+    breakParent,
+    hardlineWithoutBreakParent,
+} = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'if_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printIfExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `if_expression` node.
+ *
+ * ```
+ * // single line
+ * if (cond || cond) {}
+ *
+ * // multi line + block
+ * if (
+ *  long_cond ||
+ *  long_cond
+ * ) {
+ *    long_expr;
+ *    long_expr;
+ * }
+ *
+ * // multi line + single line
+ * if (cond) {
+ * 	return long_expr;
+ * }
+ *
+ * // multi line + single line + long expr
+ * if (
+ * 	long_cond ||
+ *  long_cond
+ * ) {
+ * 	return long_expr &&
+ * 		long_expr;
+ * }
+ * ```
+ */
+function printIfExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.nonFormattingChildren.length < 2) {
+        throw new Error('Invalid if_expression node');
+    }
+
+    const isChain = path.parent?.type == 'if_expression';
+    const hasElse = path.node.children.some((e) => e.type == 'else');
+    const condition = path.node.nonFormattingChildren[0]!;
+    const trueBranch = path.node.nonFormattingChildren[1]!;
+    const groupId = Symbol('if_expression_true');
+    const result: Doc[] = [];
+
+    const conditionPrinted = path.call(
+        (path) => {
+            let trailingComment: Doc = '';
+            if (path.node.trailingComment?.type == 'line_comment') {
+                trailingComment = lineSuffix(printTrailingComment(path));
+                path.node.disableTrailingComment();
+            }
+
+            return [print(path), trailingComment ? [trailingComment, breakParent] : ''];
+        },
+        'nonFormattingChildren',
+        0,
+    );
+
+    const conditionGroup = group([
+        'if (',
+        condition?.isList
+            ? [indent(softline), conditionPrinted, softline]
+            : [indent(softline), indent(conditionPrinted), softline],
+        ')',
+    ]);
+
+    result.push(conditionGroup);
+
+    const isTrueList = trueBranch?.isList || false;
+    const trueHasComment =
+        trueBranch.leadingComment.some((e) => e.type == 'line_comment') ||
+        trueBranch.trailingComment?.type == 'line_comment';
+
+    // true branch group
+    if (isTrueList) {
+        const truePrinted = path.call(print, 'nonFormattingChildren', 1);
+        result.push(group([' ', truePrinted], { shouldBreak: false }));
+    } else {
+        const truePrinted =
+            trueBranch.trailingComment?.type !== 'line_comment'
+                ? path.call(print, 'nonFormattingChildren', 1)
+                : path.call(
+                      (path) => {
+                          const comment = lineSuffix(printTrailingComment(path));
+                          path.node.disableTrailingComment();
+                          return [print(path), comment];
+                      },
+                      'nonFormattingChildren',
+                      1,
+                  );
+
+        result.push(
+            group([indent(line), indent(truePrinted)], {
+                id: groupId,
+            }),
+        );
+    }
+
+    // early return if there's no else block
+    if (!hasElse) {
+        return result;
+    }
+
+    const elseNode = path.node.nonFormattingChildren[2]!;
+
+    // modify the break condition for the else block
+    const elseShouldBreak =
+        elseNode.leadingComment.some((e) => e.type == 'line_comment') ||
+        elseNode.trailingComment?.type == 'line_comment' ||
+        trueHasComment;
+
+    // if true branch is a list, and there's no line comment, we add a space,
+    // if there's a line comment, we add a line break
+    //
+    // also, if the else block is another `if_expression` we follow the same
+    // logic as above
+    if (isTrueList) {
+        result.push(group([line, 'else'], { shouldBreak: trueHasComment }));
+        result.push([' ', path.call(print, 'nonFormattingChildren', 2)]);
+        return result;
+    }
+
+    const elseBranchPrinted = path.call(print, 'nonFormattingChildren', 2);
+
+    // if true branch is not a list, and else is a list, we newline
+    if ((elseNode.isList && !isTrueList) || elseNode.type == 'if_expression' || isChain) {
+        result.push([hardlineWithoutBreakParent, 'else ', group(elseBranchPrinted)]);
+        return result;
+    }
+
+    result.push(
+        group([
+            ifBreak(
+                [
+                    hardlineWithoutBreakParent,
+                    'else',
+                    group([indent(line), indent(elseBranchPrinted)]),
+                ],
+                [
+                    line,
+                    'else',
+                    group([indent(line), elseBranchPrinted], { shouldBreak: elseShouldBreak }),
+                ],
+            ),
+        ]),
+    );
+
+    return result;
+}

package/src/cst/expression/index.ts

@@ -0,0 +1,85 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Route through `_expression` nodes.
+ *
+ * @module src/cst/expression
+ */
+
+import { Node } from '../..';
+import { treeFn } from '../../printer';
+import { AstPath } from 'prettier';
+
+// Folder imports:
+import abort_expression from './abort_expression';
+import annotation_expression from './annotation_expression';
+import assign_expression from './assign_expression';
+import binary_expression from './binary_expression';
+import block_item from './block_item';
+import block from './block';
+import borrow_expression from './borrow_expression';
+import break_expression from './break_expression';
+import call_expression from './call_expression';
+import cast_expression from './cast_expression';
+import continue_expression from './continue_expression';
+import dereference_expression from './dereference_expression';
+import dot_expression from './dot_expression';
+import expression_list from './expression_list';
+import if_expression from './if_expression';
+import identified_expression from './identified_expression';
+import index_expression from './index_expression';
+import lambda_expression from './lambda_expression';
+import let_statement from './let_statement';
+import loop_expression from './loop_expression';
+import macro_call_expression from './macro_call_expression';
+import match_expression from './match_expression';
+import move_or_copy_expression from './move_or_copy_expression';
+import name_expression from './name_expression';
+import pack_expression from './pack_expression';
+import return_expression from './return_expression';
+import unary_expression from './unary_expression';
+import unit_expression from './unit_expression';
+import vector_expression from './vector_expression';
+import while_expression from './while_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    // route to separated functions
+    const result =
+        abort_expression(path) ||
+        annotation_expression(path) ||
+        assign_expression(path) ||
+        binary_expression(path) ||
+        block_item(path) ||
+        block(path) ||
+        borrow_expression(path) ||
+        break_expression(path) ||
+        call_expression(path) ||
+        cast_expression(path) ||
+        continue_expression(path) ||
+        dereference_expression(path) ||
+        dot_expression(path) ||
+        expression_list(path) ||
+        if_expression(path) ||
+        identified_expression(path) ||
+        index_expression(path) ||
+        lambda_expression(path) ||
+        let_statement(path) ||
+        loop_expression(path) ||
+        macro_call_expression(path) ||
+        match_expression(path) ||
+        move_or_copy_expression(path) ||
+        name_expression(path) ||
+        pack_expression(path) ||
+        return_expression(path) ||
+        unary_expression(path) ||
+        unit_expression(path) ||
+        vector_expression(path) ||
+        while_expression(path);
+
+    if (result !== null) {
+        return result;
+    }
+
+    return null;
+}

package/src/cst/expression/index_expression.ts

@@ -0,0 +1,37 @@
+// 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 } from '../../utilities';
+const { group } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'index_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case NODE_TYPE:
+            return printIndexExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `index_expression` node.
+ */
+export function printIndexExpression(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    return group(
+        [
+            path.call(print, 'nonFormattingChildren', 0), // lhs
+            list({ path, options, open: '[', close: ']', print, skipChildren: 1 }),
+        ],
+        { shouldBreak: false },
+    );
+}

package/src/cst/expression/lambda_expression.ts

@@ -0,0 +1,84 @@
+// 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 { printBreakableBlock, printNonBreakingBlock } from './block';
+import { list } from '../../utilities';
+const { group, join, conditionalGroup } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'lambda_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case NODE_TYPE:
+            return printLambdaExpression;
+        case 'lambda_bindings':
+            return printLambdaBindings;
+        case 'lambda_binding':
+            return printLambdaBinding;
+    }
+
+    return null;
+}
+
+/**
+ * Print `labda_expression` node.
+ * Inside:
+ * - `lambda_bindings`
+ * - `_bind`
+ */
+function printLambdaExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const children = path.node.nonFormattingChildren;
+
+    // just bindings
+    if (children.length === 1) {
+        return path.call(print, 'nonFormattingChildren', 0);
+    }
+
+    // bindings, expression or bindings, return type
+    if (children.length === 2) {
+        return join(' ', path.map(print, 'nonFormattingChildren'));
+    }
+
+    // bindings, return type, expression
+    if (children.length === 3) {
+        return [
+            path.call(print, 'nonFormattingChildren', 0), // bindings
+            ' -> ',
+            path.call(print, 'nonFormattingChildren', 1), // return type
+            ' ',
+            path.call(print, 'nonFormattingChildren', 2), // expression
+        ];
+    }
+
+    throw new Error('`lambda_expression` node should have 1, 2 or 3 children');
+}
+
+/**
+ * Print `lambda_bindings` node, contains comma-separated list of `lambda_binding` nodes.
+ */
+function printLambdaBindings(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return group(list({ path, print, options, open: '|', close: '|' }));
+}
+
+/**
+ * Print `lambda_binding` node.
+ * It can be either type annotated or just a variable binding, we know it by the number
+ * of non-formatting children.
+ */
+function printLambdaBinding(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    // simple bind, will be handled by its function
+    if (path.node.nonFormattingChildren.length === 1) {
+        return path.call(print, 'nonFormattingChildren', 0);
+    }
+
+    // with type annotation
+    if (path.node.nonFormattingChildren.length === 2) {
+        return join(': ', path.map(print, 'nonFormattingChildren'));
+    }
+
+    throw new Error('`lambda_binding` node should have 1 or 2 children');
+}

package/src/cst/expression/let_statement.ts

@@ -0,0 +1,73 @@
+// 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 { printTrailingComment } from '../../utilities';
+const { group, indent, line, indentIfBreak } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'let_statement';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printLetStatement;
+    }
+
+    return null;
+}
+
+/**
+ * Print `let_statement` node.
+ */
+function printLetStatement(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const nodes = path.node.nonFormattingChildren;
+
+    if (nodes.length === 1) {
+        return group(['let', ' ', path.call(print, 'nonFormattingChildren', 0)]);
+    }
+
+    function printWithTrailing(path: AstPath<Node>): Doc {
+        let trailingComment: Doc = '';
+        if (path.node.trailingComment?.type == 'line_comment') {
+            trailingComment = printTrailingComment(path, true);
+            path.node.disableTrailingComment();
+        }
+        return [print(path), trailingComment];
+    }
+
+    const printed = path.map(printWithTrailing, 'nonFormattingChildren');
+    const rhsNode = path.node.nonFormattingChildren.slice(-1)[0]!;
+
+    if (nodes.length === 2 && nodes[1]!.isTypeParam) {
+        const [bind, type] = printed;
+        return group(['let ', bind!, ': ', type!]);
+    }
+
+    if (nodes.length === 2) {
+        const [bind, expr] = printed;
+        const result =
+            rhsNode.isBreakableExpression || rhsNode.isFunctionCall || rhsNode.isControlFlow
+                ? ['let ', bind!, ' = ', expr!]
+                : ['let ', bind!, ' =', printLetExpression(expr!, rhsNode)];
+
+        return group(result, { shouldBreak: false });
+    }
+
+    const [bind, type, expr] = printed;
+    const result =
+        rhsNode.isBreakableExpression || rhsNode.isFunctionCall
+            ? ['let ', bind!, ': ', type!, ' = ', expr!]
+            : ['let ', bind!, ': ', type!, ' =', printLetExpression(expr!, rhsNode)];
+
+    return result;
+}
+
+function printLetExpression(expression: Doc, node: Node) {
+    const groupId = Symbol('let_expression');
+    return group([indentIfBreak(line, { groupId }), indentIfBreak(expression, { groupId })], {
+        shouldBreak: false,
+        id: groupId,
+    });
+}

package/src/cst/expression/loop_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 = 'loop_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printLoopExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `loop_expression` node.
+ *
+ * ```
+ * loop `_expression`
+ * ```
+ */
+function printLoopExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return [`loop `, path.call(print, 'nonFormattingChildren', 0)];
+}

package/src/cst/expression/macro_call_expression.ts

@@ -0,0 +1,79 @@
+// 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 } from '../../utilities';
+const { group, indentIfBreak, line, softline, ifBreak, join } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'macro_call_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printMacroCallExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `macro_call_expression` node.
+ * Inside:
+ * - `macro_module_access`
+ * - `type_arguments`
+ * - `arg_list`
+ */
+function printMacroCallExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return path.map((path) => {
+        if (path.node.type === 'macro_module_access') {
+            return printMacroModuleAccess(path, options, print);
+        }
+
+        if (path.node.type === 'arg_list') {
+            return printMacroArgsList(path, options, print);
+        }
+
+        return print(path);
+    }, 'nonFormattingChildren');
+}
+
+/**
+ * Print `macro_module_access` node.
+ * Inside:
+ * - `module_access`
+ * - `!`
+ */
+function printMacroModuleAccess(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return [path.call(print, 'nonFormattingChildren', 0), '!'];
+}
+
+/**
+ * Special function to print macro arguments list instead of `arg_list`.
+ */
+function printMacroArgsList(path: AstPath<Node>, options: MoveOptions, print: printFn) {
+    if (path.node.type !== 'arg_list') {
+        throw new Error('Expected `arg_list` node');
+    }
+
+    if (path.node.namedChildCount === 0) {
+        return '()';
+    }
+
+    const groupId = Symbol('macro_args_list');
+
+    return group(
+        list({
+            path,
+            options,
+            print,
+            open: '(',
+            close: ')',
+            addWhitespace: false,
+            shouldBreak: false,
+            indentGroup: groupId,
+        }),
+        { id: groupId },
+    );
+}