@haneullabs/prettier-plugin-move 0.3.3

package/src/cst/enum_definition.ts

@@ -0,0 +1,73 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AstPath, Doc, doc } from 'prettier';
+import { Node } from '..';
+import { MoveOptions, printFn, treeFn } from '../printer';
+import { list, printIdentifier, printTrailingComment } from '../utilities';
+const { join, lineSuffix, group } = doc.builders;
+
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case EnumDefinition.EnumDefinition:
+            return printEnumDefinition;
+        case EnumDefinition.EnumVariants:
+            return printEnumVariants;
+        case EnumDefinition.Variant:
+            return printVariant;
+
+        // identifiers
+        case EnumDefinition.EnumIdentifier:
+        case EnumDefinition.VariantIdentifier:
+            return printIdentifier;
+    }
+
+    return null;
+}
+
+export enum EnumDefinition {
+    EnumDefinition = 'enum_definition',
+    EnumVariants = 'enum_variants',
+    Variant = 'variant',
+
+    EnumIdentifier = 'enum_identifier',
+    VariantIdentifier = 'variant_identifier',
+}
+
+/**
+ * Print `enum_definition` node.
+ */
+export function printEnumDefinition(path: AstPath<Node>, _opt: MoveOptions, print: printFn): Doc {
+    const isPublic = path.node.child(0)?.type == 'public';
+
+    return [isPublic ? 'public ' : '', 'enum ', path.map(print, 'nonFormattingChildren')];
+}
+
+/**
+ * Print `enum_variants` node.
+ * List of `variant` nodes.
+ */
+export function printEnumVariants(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.nonFormattingChildren.length === 0) {
+        return ' {}';
+    }
+
+    return [
+        ' ',
+        group(list({ path, print, options, open: '{', close: '}', addWhitespace: true }), {
+            shouldBreak: true,
+        }),
+    ];
+}
+
+/**
+ * Print `variant` node.
+ * Inside:
+ * - `variant_identifier`
+ * - `datatype_fields` (optional)
+ */
+export function printVariant(path: AstPath<Node>, _opt: MoveOptions, print: printFn): Doc {
+    const trailing = lineSuffix(printTrailingComment(path, false));
+    path.node.disableTrailingComment();
+    return [path.map(print, 'nonFormattingChildren'), trailing];
+}

package/src/cst/expression/abort_expression.ts

@@ -0,0 +1,35 @@
+// 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 { group, indent, line } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'abort_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printAbortExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `abort_expression` node.
+ */
+function printAbortExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const expression = path.node.nonFormattingChildren[0];
+    const printed = path.call(print, 'nonFormattingChildren', 0);
+
+    if (!expression) return 'abort';
+
+    return group([
+        'abort',
+        expression?.isList || expression?.isControlFlow
+            ? [' ', printed]
+            : [indent(line), indent(printed)],
+    ]);
+}

package/src/cst/expression/annotation_expression.ts

@@ -0,0 +1,38 @@
+// 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 { group, indent, softline } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'annotation_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printAnnotationExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `annotation_expression` node.
+ */
+function printAnnotationExpression(path: AstPath<Node>, _opt: MoveOptions, print: printFn): Doc {
+    const children = path.map(print, 'nonFormattingChildren');
+    if (children.length !== 2) {
+        throw new Error('`annotation_expression` node should have 2 children');
+    }
+
+    return group([
+        '(',
+        indent(softline),
+        indent(children[0]!), // expression
+        ': ',
+        children[1]!, // type
+        softline,
+        ')',
+    ]);
+}

package/src/cst/expression/assign_expression.ts

@@ -0,0 +1,66 @@
+// 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 } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'assign_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printAssignExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `assign_expression` node.
+ */
+function printAssignExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.nonFormattingChildren.length !== 2) {
+        throw new Error('`assign_expression` must have 2 children');
+    }
+
+    const result: Doc[] = [];
+    let shouldBreak = false;
+
+    // together with the LHS we print trailing comment if there is one
+    result.push(
+        path.call(
+            (lhs) => {
+                const hasComment = !!lhs.node.trailingComment;
+
+                if (lhs.node.trailingComment?.type == 'line_comment') {
+                    shouldBreak = true;
+                    const trailingLineComment = printTrailingComment(lhs, true);
+                    lhs.node.disableTrailingComment();
+                    return [print(lhs), ' =', indent(trailingLineComment)];
+                }
+
+                return [print(lhs), hasComment ? '=' : ' ='];
+            },
+            'nonFormattingChildren',
+            0,
+        ),
+    );
+
+    const rhs = path.node.nonFormattingChildren[1]!;
+    if ((rhs.isControlFlow || rhs.isList) && !shouldBreak) {
+        result.push(group([' ', path.call(print, 'nonFormattingChildren', 1)]));
+    } else {
+        // then print the rhs
+        result.push(
+            group([
+                shouldBreak ? '' : indent(line),
+                indent(path.call(print, 'nonFormattingChildren', 1)),
+            ]),
+        );
+    }
+
+    return result;
+}

package/src/cst/expression/binary_expression.ts

@@ -0,0 +1,75 @@
+// 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 { group, line } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'binary_expression';
+
+// TODO: re-enable binary expression once we figure out how to achieve it.
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return () => path.node.text;
+        // TODO: re-enable binary expression once we figure out how to achieve it.
+        // return printBinaryExpression;
+    } else if (path.node.type === 'binary_operator') {
+        // return printBinaryOperator;
+        // TODO: re-enable binary expression once we figure out how to achieve it.
+        return () => path.node.text;
+    }
+
+    return null;
+}
+
+/**
+ * Print `binary_expression` node.
+ * (Currently disabled)
+ */
+function printBinaryExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.nonFormattingChildren.length != 3) {
+        throw new Error('`binary_expression` node should have 3 children');
+    }
+
+    const [one, two, three] = path.map(print, 'nonFormattingChildren');
+    const rhs = path.node.nonFormattingChildren[2];
+
+    if (rhs?.type === 'block' || rhs?.type === 'expression_list') {
+        return [one!, ' ', two!, ' ', three!];
+    }
+
+    return [one!, ' ', two!, group([line, three!], { shouldBreak: false })];
+}
+
+/**
+ * Print `binary_operator` node.
+ */
+export function printBinaryOperator(path: AstPath<Node>, _opt: MoveOptions, _p: printFn): Doc {
+    return path.node.text;
+}
+
+/**
+
+ or: '||',
+ and:  '&&',
+ eq: '==',
+ neq:  '!=',
+ lt: '<',
+ gt: '>',
+ le: '<=',
+ ge: '>=',
+ bit_or: '|',
+ xor:  '^',
+ bit_and: '&',
+ shl:  '<<',
+ shr:  '>>',
+ add:  '+',
+ sub:  '-',
+ mul:  '*',
+ div:  '/',
+ mod:  '%'
+
+
+*/

package/src/cst/expression/block.ts

@@ -0,0 +1,72 @@
+// 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 { block, shouldBreakFirstChild } from '../../utilities';
+const { group, indent, join, conditionalGroup, hardlineWithoutBreakParent } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'block';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printBlock;
+    }
+
+    return null;
+}
+
+/**
+ * Special case of `block` node, that does not break the parent. A must-have for
+ * lambda expressions.
+ */
+export function printNonBreakingBlock(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    const length = path.node.nonFormattingChildren.length;
+
+    if (length == 0) {
+        return '{}';
+    }
+
+    return group([
+        '{',
+        indent(hardlineWithoutBreakParent),
+        indent(join(hardlineWithoutBreakParent, path.map(print, 'namedAndEmptyLineChildren'))),
+        hardlineWithoutBreakParent,
+        '}',
+    ]);
+}
+
+export function printBreakableBlock(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    const length = path.node.nonFormattingChildren.length;
+
+    if (length == 0) {
+        return '{}';
+    }
+
+    return block({
+        options,
+        print,
+        path,
+        shouldBreak: shouldBreakFirstChild(path),
+    });
+}
+
+/**
+ * Print `block` node.
+ */
+export function printBlock(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return conditionalGroup([
+        printBreakableBlock(path, options, print),
+        printNonBreakingBlock(path, options, print),
+    ]);
+}

package/src/cst/expression/block_item.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';
+import { printTrailingComment } from '../../utilities';
+const { group, lineSuffix } = doc.builders;
+
+/** The type of the node implemented in this file */
+const NODE_TYPE = 'block_item';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printBlockItem;
+    }
+
+    return null;
+}
+
+/**
+ * Print `block_item` node.
+ */
+function printBlockItem(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const trailing = lineSuffix(printTrailingComment(path));
+    path.node.disableTrailingComment();
+
+    return [group([path.call(print, 'nonFormattingChildren', 0), ';', trailing])];
+}

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

package/src/cst/expression/break_expression.ts

@@ -0,0 +1,33 @@
+// 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 } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'break_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printBreakExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `break_expression` node.
+ */
+export function printBreakExpression(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    if (path.node.nonFormattingChildren.length > 0) {
+        return join(' ', ['break', ...path.map(print, 'nonFormattingChildren')]);
+    }
+
+    return 'break';
+}

package/src/cst/expression/call_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';
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'call_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printCallExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `call_expression` node.
+ * Inside:
+ * - `module_access`
+ * - `type_arguments`
+ * - `arg_list`
+ */
+function printCallExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return path.map(print, 'nonFormattingChildren');
+}

package/src/cst/expression/cast_expression.ts

@@ -0,0 +1,35 @@
+// 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 } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'cast_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printCastExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `cast_expression` node.
+ * Inside:
+ * - `expression`
+ * - `type`
+ */
+function printCastExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const parens = path.node.child(0)?.text == '(';
+    const children = path.map(print, 'nonFormattingChildren');
+
+    if (parens) {
+        return ['(', join(' as ', children), ')'];
+    }
+
+    return join(' as ', children);
+}

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

package/src/cst/expression/dereference_expression.ts

@@ -0,0 +1,33 @@
+// 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 = 'dereference_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printDereferenceExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `dereference_expression` node.
+ *
+ * Inside:
+ * - `*`
+ * - `_expression`
+ */
+function printDereferenceExpression(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    return ['*', path.call(print, 'nonFormattingChildren', 0)];
+}

package/src/cst/expression/dot_expression.ts

@@ -0,0 +1,89 @@
+// 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 { printLeadingComment, printTrailingComment } from '../../utilities';
+const { group, indent, ifBreak, breakParent, lineSuffix, softline } = doc.builders;
+
+/** The type of the node implemented in this file */
+export const NODE_TYPE = 'dot_expression';
+
+export default function (path: AstPath<Node>): treeFn | null {
+    if (path.node.type === NODE_TYPE) {
+        return printDotExpression;
+    }
+
+    return null;
+}
+
+/**
+ * Print `dot_expression` node.
+ *
+ * Note, that it's intentional, that the return value is not a `group`. For more info,
+ * @see [This Issue](https://github.com/prettier/prettier/issues/15710#issuecomment-1836701758)
+ */
+function printDotExpression(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    if (path.node.nonFormattingChildren.length < 2) {
+        throw new Error('`dot_expression` node should have at least 2 children');
+    }
+
+    // chain is a `dot_expression` that is a child of another `dot_expression`
+    // or which has a `dot_expression` as a child
+    const isChain =
+        path.node.nonFormattingChildren[0]!.type === NODE_TYPE ||
+        path.node.parent?.type === NODE_TYPE;
+
+    const isParentList = path.node.parent?.isList;
+
+    // if dot expression has a trailing comment and it breaks, we need to
+    // print it manually after the rhs
+    const trailing = lineSuffix(printTrailingComment(path));
+
+    const lhs = path.call(
+        (path) => printNode(path, options, print, false),
+        'nonFormattingChildren',
+        0,
+    );
+    const rhs = path.call(
+        (path) => printNode(path, options, print, true),
+        'nonFormattingChildren',
+        1,
+    );
+
+    // if it's a single expression, we don't need to group it
+    // and optionally no need to break it; no need to special
+    // print it in this case
+    if (!isChain) {
+        const right = path.node.nonFormattingChildren[1]!;
+        if (right.leadingComment.length > 0) {
+            path.node.disableTrailingComment();
+            return [lhs, indent(softline), indent(rhs), trailing];
+        }
+
+        return [lhs, rhs];
+    }
+
+    path.node.disableTrailingComment();
+    const parts = [lhs, ifBreak(indent(softline), ''), ifBreak(indent(rhs), rhs), trailing];
+
+    // group if parent is not `dot_expression`
+    if (isChain && path.node.parent?.type !== NODE_TYPE) {
+        return group(parts);
+    }
+
+    return parts;
+}
+
+// In `dot_expression` we need to keep the `.` in the same line as the `rhs`,
+// so we need to prevent automatic printing of comments in the `print` call, and
+// perform it manually.
+function printNode(path: AstPath<Node>, options: MoveOptions, print: printFn, insertDot = false) {
+    const leading = printLeadingComment(path, options);
+    const shouldBreak =
+        path.node.leadingComment.length > 0 || path.node.trailingComment?.type === 'line_comment';
+
+    path.node.disableLeadingComment();
+    return [leading, shouldBreak ? breakParent : '', insertDot ? '.' : '', print(path)];
+}