npm - @haneullabs/prettier-plugin-move - Versions diffs - 0.3.3 - Mend

@haneullabs/prettier-plugin-move 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (149) hide show

package/CHANGELOG.md +67 -0
package/CONTRIBUTING.md +31 -0
package/README.md +96 -0
package/bin/prettier-move.js +29 -0
package/out/cst/annotation.js +64 -0
package/out/cst/annotation.js.map +1 -0
package/out/cst/common.js +376 -0
package/out/cst/common.js.map +1 -0
package/out/cst/constant.js +92 -0
package/out/cst/constant.js.map +1 -0
package/out/cst/enum_definition.js +69 -0
package/out/cst/enum_definition.js.map +1 -0
package/out/cst/expression/abort_expression.js +32 -0
package/out/cst/expression/abort_expression.js.map +1 -0
package/out/cst/expression/annotation_expression.js +35 -0
package/out/cst/expression/annotation_expression.js.map +1 -0
package/out/cst/expression/assign_expression.js +51 -0
package/out/cst/expression/assign_expression.js.map +1 -0
package/out/cst/expression/binary_expression.js +70 -0
package/out/cst/expression/binary_expression.js.map +1 -0
package/out/cst/expression/block.js +58 -0
package/out/cst/expression/block.js.map +1 -0
package/out/cst/expression/block_item.js +25 -0
package/out/cst/expression/block_item.js.map +1 -0
package/out/cst/expression/borrow_expression.js +26 -0
package/out/cst/expression/borrow_expression.js.map +1 -0
package/out/cst/expression/break_expression.js +27 -0
package/out/cst/expression/break_expression.js.map +1 -0
package/out/cst/expression/call_expression.js +25 -0
package/out/cst/expression/call_expression.js.map +1 -0
package/out/cst/expression/cast_expression.js +31 -0
package/out/cst/expression/cast_expression.js.map +1 -0
package/out/cst/expression/continue_expression.js +26 -0
package/out/cst/expression/continue_expression.js.map +1 -0
package/out/cst/expression/dereference_expression.js +27 -0
package/out/cst/expression/dereference_expression.js.map +1 -0
package/out/cst/expression/dot_expression.js +66 -0
package/out/cst/expression/dot_expression.js.map +1 -0
package/out/cst/expression/expression_list.js +26 -0
package/out/cst/expression/expression_list.js.map +1 -0
package/out/cst/expression/identified_expression.js +28 -0
package/out/cst/expression/identified_expression.js.map +1 -0
package/out/cst/expression/if_expression.js +133 -0
package/out/cst/expression/if_expression.js.map +1 -0
package/out/cst/expression/index.js +74 -0
package/out/cst/expression/index.js.map +1 -0
package/out/cst/expression/index_expression.js +28 -0
package/out/cst/expression/index_expression.js.map +1 -0
package/out/cst/expression/lambda_expression.js +72 -0
package/out/cst/expression/lambda_expression.js.map +1 -0
package/out/cst/expression/let_statement.js +59 -0
package/out/cst/expression/let_statement.js.map +1 -0
package/out/cst/expression/loop_expression.js +27 -0
package/out/cst/expression/loop_expression.js.map +1 -0
package/out/cst/expression/macro_call_expression.js +66 -0
package/out/cst/expression/macro_call_expression.js.map +1 -0
package/out/cst/expression/match_expression.js +86 -0
package/out/cst/expression/match_expression.js.map +1 -0
package/out/cst/expression/move_or_copy_expression.js +27 -0
package/out/cst/expression/move_or_copy_expression.js.map +1 -0
package/out/cst/expression/name_expression.js +26 -0
package/out/cst/expression/name_expression.js.map +1 -0
package/out/cst/expression/pack_expression.js +27 -0
package/out/cst/expression/pack_expression.js.map +1 -0
package/out/cst/expression/return_expression.js +44 -0
package/out/cst/expression/return_expression.js.map +1 -0
package/out/cst/expression/unary_expression.js +26 -0
package/out/cst/expression/unary_expression.js.map +1 -0
package/out/cst/expression/unit_expression.js +17 -0
package/out/cst/expression/unit_expression.js.map +1 -0
package/out/cst/expression/vector_expression.js +80 -0
package/out/cst/expression/vector_expression.js.map +1 -0
package/out/cst/expression/while_expression.js +42 -0
package/out/cst/expression/while_expression.js.map +1 -0
package/out/cst/formatting.js +100 -0
package/out/cst/formatting.js.map +1 -0
package/out/cst/function_definition.js +248 -0
package/out/cst/function_definition.js.map +1 -0
package/out/cst/literal.js +68 -0
package/out/cst/literal.js.map +1 -0
package/out/cst/module.js +158 -0
package/out/cst/module.js.map +1 -0
package/out/cst/source_file.js +38 -0
package/out/cst/source_file.js.map +1 -0
package/out/cst/struct_definition.js +209 -0
package/out/cst/struct_definition.js.map +1 -0
package/out/cst/use_declaration.js +212 -0
package/out/cst/use_declaration.js.map +1 -0
package/out/imports-grouping.js +259 -0
package/out/imports-grouping.js.map +1 -0
package/out/index.js +97 -0
package/out/index.js.map +1 -0
package/out/printer.js +69 -0
package/out/printer.js.map +1 -0
package/out/tree.js +371 -0
package/out/tree.js.map +1 -0
package/out/utilities.js +251 -0
package/out/utilities.js.map +1 -0
package/package.json +34 -0
package/prettier.config.js +12 -0
package/src/cst/annotation.ts +71 -0
package/src/cst/common.ts +430 -0
package/src/cst/constant.ts +110 -0
package/src/cst/enum_definition.ts +73 -0
package/src/cst/expression/abort_expression.ts +35 -0
package/src/cst/expression/annotation_expression.ts +38 -0
package/src/cst/expression/assign_expression.ts +66 -0
package/src/cst/expression/binary_expression.ts +75 -0
package/src/cst/expression/block.ts +72 -0
package/src/cst/expression/block_item.ts +29 -0
package/src/cst/expression/borrow_expression.ts +28 -0
package/src/cst/expression/break_expression.ts +33 -0
package/src/cst/expression/call_expression.ts +28 -0
package/src/cst/expression/cast_expression.ts +35 -0
package/src/cst/expression/continue_expression.ts +29 -0
package/src/cst/expression/dereference_expression.ts +33 -0
package/src/cst/expression/dot_expression.ts +89 -0
package/src/cst/expression/expression_list.ts +28 -0
package/src/cst/expression/identified_expression.ts +30 -0
package/src/cst/expression/if_expression.ts +177 -0
package/src/cst/expression/index.ts +85 -0
package/src/cst/expression/index_expression.ts +37 -0
package/src/cst/expression/lambda_expression.ts +84 -0
package/src/cst/expression/let_statement.ts +73 -0
package/src/cst/expression/loop_expression.ts +29 -0
package/src/cst/expression/macro_call_expression.ts +79 -0
package/src/cst/expression/match_expression.ts +102 -0
package/src/cst/expression/move_or_copy_expression.ts +29 -0
package/src/cst/expression/name_expression.ts +28 -0
package/src/cst/expression/pack_expression.ts +29 -0
package/src/cst/expression/return_expression.ts +50 -0
package/src/cst/expression/unary_expression.ts +28 -0
package/src/cst/expression/unit_expression.ts +18 -0
package/src/cst/expression/vector_expression.ts +97 -0
package/src/cst/expression/while_expression.ts +45 -0
package/src/cst/formatting.ts +100 -0
package/src/cst/function_definition.ts +300 -0
package/src/cst/literal.ts +69 -0
package/src/cst/module.ts +191 -0
package/src/cst/source_file.ts +38 -0
package/src/cst/struct_definition.ts +267 -0
package/src/cst/use_declaration.ts +238 -0
package/src/imports-grouping.ts +300 -0
package/src/index.ts +119 -0
package/src/printer.ts +93 -0
package/src/tree.ts +438 -0
package/src/utilities.ts +387 -0
package/tree-sitter-move.wasm +0 -0
package/tsconfig.json +26 -0

package/src/cst/function_definition.ts ADDED Viewed

@@ -0,0 +1,300 @@
+// 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 } from './expression/block';
+import { list, printIdentifier } from '../utilities';
+const { join, group } = doc.builders;
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case FunctionDefinition.NativeFunctionDefinition:
+            return printNativeFunctionDefinition;
+        case FunctionDefinition.FunctionDefinition:
+            return printFunctionDefinition;
+        case FunctionDefinition.MacroFunctionDefinition:
+            return printMacroFunctionDefinition;
+        case FunctionDefinition.VisibilityModifier:
+            return printVisibilityModifier;
+        case FunctionDefinition.FunctionParameters:
+            return printFunctionParameters;
+        case FunctionDefinition.FunctionParameter:
+            return printFunctionParameter;
+        case FunctionDefinition.MutFunctionParameter:
+            return printMutFunctionParameter;
+        case FunctionDefinition.ReturnType:
+            return printReturnType;
+        case FunctionDefinition.TypeArguments:
+            return printTypeArguments;
+        case FunctionDefinition.TypeParameters:
+            return printTypeParameters;
+        case FunctionDefinition.TypeParameter:
+            return printTypeParameter;
+        // identifiers
+        case FunctionDefinition.FunctionIdentifier:
+        case FunctionDefinition.TypeParameterIdentifier:
+            return printIdentifier;
+    }
+    return null;
+}
+/**
+ * Function Definition, contains the following:
+ * ```
+ * <visibility> fun <identifier> (<parameters>) <return_type> <body>
+ * ```
+ */
+export enum FunctionDefinition {
+    FunctionDefinition = 'function_definition',
+    FunctionIdentifier = 'function_identifier',
+    NativeFunctionDefinition = 'native_function_definition',
+    MacroFunctionDefinition = 'macro_function_definition',
+    VisibilityModifier = 'visibility_modifier',
+    FunctionParameters = 'function_parameters',
+    FunctionParameter = 'function_parameter',
+    MutFunctionParameter = 'mut_function_parameter',
+    ReturnType = 'ret_type',
+    TypeArguments = 'type_arguments',
+    TypeParameters = 'type_parameters',
+    TypeParameter = 'type_parameter',
+    TypeParameterIdentifier = 'type_parameter_identifier',
+}
+export type Modifiers = {
+    native?: boolean;
+    public?: boolean;
+    entry?: boolean;
+    ['public(friend)']?: boolean;
+    ['public(package)']?: boolean;
+};
+/**
+ * Print `function_definition` node.
+ */
+export function printFunctionDefinition(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    const nodes = path.node.nonFormattingChildren;
+    const retIndex = nodes.findIndex((e) => e.type == FunctionDefinition.ReturnType);
+    const modifiers = getModifiers(path);
+    const printCb = (path: AstPath<Node>) =>
+        path.node.type === 'block' ? printBreakableBlock(path, options, print) : print(path);
+    const signature = [
+        printModifiers(modifiers),
+        'fun ',
+        path.map((path) => {
+            // We already added modifiers in the previous step
+            if (path.node.type == 'modifier') return '';
+            if (path.node.type == 'block') return '';
+            if (path.node.type == 'ret_type') return '';
+            if (path.node.isFormatting) return '';
+            return print(path);
+        }, 'nonFormattingChildren'),
+    ];
+    return [
+        group([signature, path.call(print, 'nonFormattingChildren', retIndex)]),
+        ' ',
+        path.call(printCb, 'nonFormattingChildren', nodes.length - 1),
+    ];
+}
+export function printNativeFunctionDefinition(
+    path: AstPath<Node>,
+    _opt: MoveOptions,
+    print: printFn,
+): Doc {
+    const modifiers = getModifiers(path);
+    return [
+        printModifiers(modifiers),
+        'fun ',
+        group(
+            path.map((path) => {
+                if (path.node.type == 'modifier') return '';
+                return print(path);
+            }, 'nonFormattingChildren'),
+        ),
+        ';',
+    ];
+}
+/**
+ * Print `macro_function_definition` node.
+ */
+export function printMacroFunctionDefinition(
+    path: AstPath<Node>,
+    _opt: MoveOptions,
+    print: printFn,
+): Doc {
+    const modifiers = getModifiers(path);
+    return [
+        printModifiers(modifiers),
+        'macro fun ',
+        group(
+            path.map((path) => {
+                if (path.node.type == 'modifier') return '';
+                if (path.node.type == 'block') return '';
+                return print(path);
+            }, 'nonFormattingChildren'),
+        ),
+        ' ',
+        path.call(print, 'nonFormattingChildren', path.node.nonFormattingChildren.length - 1),
+    ];
+}
+/**
+ * Print `visibility_modifier` node.
+ * Always followed by a space.
+ */
+export function printVisibilityModifier(
+    path: AstPath<Node>, //  | Node | null,
+    _opt: MoveOptions,
+    _print: printFn,
+): Doc {
+    return [path.node.text, ' '];
+}
+/**
+ * Print `function_parameters` node.
+ */
+export function printFunctionParameters(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    return list({
+        path,
+        print,
+        options,
+        open: '(',
+        close: ')',
+        shouldBreak: false,
+    });
+}
+/**
+ * Print `function_parameter` node.
+ */
+export function printFunctionParameter(
+    path: AstPath<Node>,
+    _opt: MoveOptions,
+    print: printFn,
+): Doc {
+    const isMut = path.node.child(0)?.type == 'mut';
+    const isDollar = path.node.children.find((c) => c.type == '$');
+    return group([
+        isMut ? 'mut ' : '',
+        isDollar ? '$' : '',
+        path.call(print, 'nonFormattingChildren', 0), // variable_identifier
+        ': ',
+        path.call(print, 'nonFormattingChildren', 1), // type
+    ]);
+}
+/**
+ * Print `mut` function parameter.
+ */
+export function printMutFunctionParameter(
+    path: AstPath<Node>,
+    _opt: MoveOptions,
+    print: printFn,
+): Doc {
+    return ['mut ', path.call(print, 'nonFormattingChildren', 0)];
+}
+/**
+ * Print `ret_type` node.
+ */
+export function printReturnType(path: AstPath<Node>, _opt: MoveOptions, print: printFn): Doc {
+    return [': ', path.call(print, 'nonFormattingChildren', 0)];
+}
+/**
+ * Print `type_arguments` node.
+ */
+export function printTypeArguments(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return group(
+        list({
+            path,
+            print,
+            options,
+            open: '<',
+            close: '>',
+            shouldBreak: false,
+        }),
+    );
+}
+/**
+ * Print `type_parameters` node.
+ */
+export function printTypeParameters(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    return group(
+        list({
+            path,
+            print,
+            options,
+            open: '<',
+            close: '>',
+            shouldBreak: false,
+        }),
+    );
+}
+/**
+ * Print `type_parameter` node.
+ */
+export function printTypeParameter(path: AstPath<Node>, _opt: MoveOptions, print: printFn): Doc {
+    const isDollar = path.node.child(0)?.type == '$';
+    const isPhantom = path.node.child(0)?.type == 'phantom';
+    const parameter = path.call(print, 'nonFormattingChildren', 0);
+    const abilities = path.map(print, 'nonFormattingChildren').slice(1);
+    return [
+        isDollar ? '$' : '',
+        isPhantom ? 'phantom ' : '',
+        parameter,
+        abilities.length > 0 ? ': ' : '',
+        join(' + ', abilities),
+    ];
+}
+/**
+ * Helper function to get modifiers.
+ */
+function getModifiers(path: AstPath<Node>): Modifiers {
+    const nodes = path.node.nonFormattingChildren;
+    return nodes
+        .filter((e) => e.type == 'modifier')
+        .map((e) => e.text.replace(' ', '')) // removes the space in `public (package)`
+        .reduce((acc, e) => ({ ...acc, [e]: true }), {});
+}
+/**
+ * Helper function to print modifiers.
+ */
+function printModifiers(modifiers: Modifiers): Doc {
+    return [
+        modifiers.public ? 'public ' : '',
+        modifiers['public(package)'] ? 'public(package) ' : '',
+        modifiers['public(friend)'] ? 'public(friend) ' : '',
+        modifiers.entry ? 'entry ' : '',
+        modifiers.native ? 'native ' : '',
+    ];
+}

package/src/cst/literal.ts ADDED Viewed

@@ -0,0 +1,69 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { AstPath, Doc } from 'prettier';
+import { Node } from '..';
+import { treeFn } from '../printer';
+/**
+ * Node: `_literal_value` in the grammar.json.
+ */
+export enum Literal {
+    AddressLiteral = 'address_literal',
+    BoolLiteral = 'bool_literal',
+    NumLiteral = 'num_literal',
+    HexStringLiteral = 'hex_string_literal',
+    ByteStringLiteral = 'byte_string_literal',
+}
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case Literal.AddressLiteral:
+            return printAddressLiteral;
+        case Literal.BoolLiteral:
+            return printBoolLiteral;
+        case Literal.NumLiteral:
+            return printNumLiteral;
+        case Literal.HexStringLiteral:
+            return printHexStringLiteral;
+        case Literal.ByteStringLiteral:
+            return printByteStringLiteral;
+    }
+    return null;
+}
+/**
+ * Print `byte_string_literal` node.
+ */
+export function printByteStringLiteral(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+/**
+ * Print `bool_literal` node.
+ */
+export function printBoolLiteral(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+/**
+ * Print `num_literal` node.
+ */
+export function printNumLiteral(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+/**
+ * Print `address_literal` node.
+ */
+export function printAddressLiteral(path: AstPath<Node>): Doc {
+    return path.node.text;
+}
+/**
+ * Print `hex_literal` node.
+ */
+export function printHexStringLiteral(path: AstPath<Node>): Doc {
+    return path.node.text;
+}

package/src/cst/module.ts ADDED Viewed

@@ -0,0 +1,191 @@
+// Copyright (c) The Move Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Node } from '..';
+import { MoveOptions, printFn, treeFn } from '../printer';
+import { AstPath, Doc, ParserOptions, doc } from 'prettier';
+import { FunctionDefinition } from './function_definition';
+import { StructDefinition } from './struct_definition';
+import * as Constant from './constant';
+import { UseDeclaration } from './use_declaration';
+import { printImports, collectImports } from '../imports-grouping';
+import { EnumDefinition } from './enum_definition';
+import { printIdentifier } from '../utilities';
+const { join, hardline, indent } = doc.builders;
+/**
+ * Creates a callback function to print modules and module-related nodes.
+ */
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case Module.ModuleExtensionDefinition:
+            return printModuleExtensionDefinition;
+        case Module.ModuleDefinition:
+            return printModuleDefinition;
+        case Module.ModuleIdentity:
+            return printModuleIdentity;
+        case Module.ModuleIdentifier:
+            return printIdentifier;
+        case Module.ModuleBody:
+            return printModuleBody;
+        default:
+            return null;
+    }
+}
+/**
+ * Module - top-level definition in a Move source file.
+ */
+export enum Module {
+    ModuleExtensionDefinition = 'module_extension_definition',
+    ModuleDefinition = 'module_definition',
+    BlockComment = 'block_comment',
+    ModuleIdentity = 'module_identity',
+    ModuleIdentifier = 'module_identifier',
+    ModuleBody = 'module_body',
+}
+/**
+ * Print `module_extension_definition` node.
+ */
+export function printModuleExtensionDefinition(
+    path: AstPath<Node>,
+    _options: MoveOptions,
+    print: printFn,
+): Doc {
+    return ['extend ', path.call(print, 'nonFormattingChildren', 0)];
+}
+/**
+ * Print `module_definition` node.
+ */
+export function printModuleDefinition(
+    path: AstPath<Node>,
+    options: MoveOptions,
+    print: printFn,
+): Doc {
+    let useLabel = false;
+    // when option is present we must check that there's only one module per file
+    if (options.useModuleLabel) {
+        const modules = path.parent!.nonFormattingChildren.filter(
+            (node) =>
+                node.type === 'module_definition' || node.type === 'module_extension_definition',
+        );
+        useLabel = modules.length == 1;
+    }
+    // module definition can be a part of the extension, do decide whether to use
+    // the label for it, we need to check its parent's parent
+    if (options.useModuleLabel && path.parent!.type === 'module_extension_definition') {
+        const modules = path.parent!.parent!.nonFormattingChildren.filter(
+            (node) =>
+                node.type === 'module_definition' || node.type === 'module_extension_definition',
+        );
+        useLabel = modules.length == 1;
+    }
+    const result = ['module ', path.call(print, 'nonFormattingChildren', 0)];
+    // if we're using the label, we must add a semicolon and print the body in a
+    // new line
+    if (useLabel) {
+        // print hard lines only if there is more than one child
+        if (path.node.nonFormattingChildren[1]!.children.length > 1) {
+            return result.concat([
+                ';',
+                hardline,
+                hardline,
+                path.call(print, 'nonFormattingChildren', 1),
+            ]);
+        } else {
+            return result.concat([';']);
+        }
+    }
+    // when not module mabel, module body is a block with curly braces and
+    // indentation
+    return result.concat([
+        ' {',
+        indent(hardline),
+        indent(path.call(print, 'nonFormattingChildren', 1)),
+        hardline,
+        '}',
+    ]);
+}
+/**
+ * Print `module_identity` node.
+ */
+function printModuleIdentity(path: AstPath<Node>, options: ParserOptions, print: printFn): Doc {
+    return join('::', path.map(print, 'nonFormattingChildren'));
+}
+/**
+ * Members that must be separated by an empty line if they are next to each other.
+ * For example, a function definition followed by a struct definition.
+ */
+const separatedMembers = [
+    FunctionDefinition.FunctionDefinition,
+    StructDefinition.StructDefinition,
+    Constant.NODE_TYPE,
+    UseDeclaration.UseDeclaration,
+    UseDeclaration.FriendDeclaration,
+    EnumDefinition.EnumDefinition,
+] as string[];
+/**
+ * Print `module_body` node.
+ *
+ * We need to preserve spacing between members (functions, structs, constants, etc.).
+ * We need to only allow a single empty line (if there are more than one, we should remove them).
+ * Additionally, if `groupImports` is set to `package` or `module`, we should group imports and
+ * print them at the top of the module.
+ */
+function printModuleBody(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    const nodes = path.node.namedAndEmptyLineChildren;
+    const importsDoc = [] as Doc[];
+    const imports = collectImports(path.node);
+    if (imports.size > 0) {
+        importsDoc.push(
+            ...(printImports(imports, options.autoGroupImports as 'package' | 'module') as Doc[]),
+        );
+    }
+    const bodyDoc = [] as Doc[];
+    path.each((path, i) => {
+        const next = nodes[i + 1];
+        // empty lines should be removed if they are next to grouped imports
+        if (path.node.isEmptyLine && path.node.previousNamedSibling?.isGroupedImport) return;
+        if (path.node.isGroupedImport) return;
+        if (path.node.isEmptyLine && !path.node.previousNamedSibling) return;
+        if (
+            separatedMembers.includes(path.node.type) &&
+            separatedMembers.includes(next?.type || '') &&
+            path.node.type !== next?.type
+        ) {
+            return bodyDoc.push([path.call(print), hardline]);
+        }
+        // force add empty line after function definitions
+        if (
+            path.node.type === FunctionDefinition.FunctionDefinition &&
+            next?.type === FunctionDefinition.FunctionDefinition
+        ) {
+            return bodyDoc.push([path.call(print), hardline]);
+        }
+        return bodyDoc.push(path.call(print));
+    }, 'namedAndEmptyLineChildren');
+    if (bodyDoc.length > 0 && importsDoc.length > 0) {
+        bodyDoc.unshift(''); // add empty line before first member
+    }
+    return join(hardline, importsDoc.concat(bodyDoc));
+}

package/src/cst/source_file.ts ADDED Viewed

@@ -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 { hardline, join } = doc.builders;
+/**
+ * Print a source node.
+ */
+export default function (path: AstPath<Node>): treeFn | null {
+    switch (path.node.type) {
+        case SourceFile.SourceFile:
+            return printSourceFile;
+    }
+    return null;
+}
+export enum SourceFile {
+    SourceFile = 'source_file',
+}
+/**
+ * Print `source_file` node.
+ *
+ * Print all non-formatting children separated by a hardline.
+ * Also print empty lines with leading comments, this allows us to maintain structure like this:
+ * ```
+ * // Copyright
+ * `empty_line`
+ * // module comment
+ * module book::book { ... }
+ * ```
+ */
+function printSourceFile(path: AstPath<Node>, options: MoveOptions, print: printFn): Doc {
+    return [join(hardline, path.map(print, 'namedAndEmptyLineChildren')), hardline];
+}