feat(acton): add very initial support for acton fmt (#280)

Author: i582

editors/code/src/acton/ActonCommand.ts

@@ -155,7 +155,7 @@ export class CheckCommand extends ActonCommand {
     public override getArguments(): string[] {
         const args: string[] = []
         if (this.json) {
-            args.push("--json")
+            args.push("--output-format=json")
         }
         if (this.target.trim() !== "") {
             args.push(this.target)
@@ -164,6 +164,16 @@ export class CheckCommand extends ActonCommand {
     }
 }
 
+export class FormatCommand extends ActonCommand {
+    public constructor(public targets: readonly string[] = []) {
+        super("fmt")
+    }
+
+    public override getArguments(): string[] {
+        return this.targets.filter(target => target.trim() !== "")
+    }
+}
+
 export class CustomCommand extends ActonCommand {
     public constructor(
         command: string,

editors/code/src/acton/ActonFormatter.ts

@@ -0,0 +1,94 @@
+//  SPDX-License-Identifier: MIT
+//  Copyright © 2026 TON Core
+
+import * as fs from "node:fs/promises"
+import * as os from "node:os"
+import * as path from "node:path"
+
+import * as vscode from "vscode"
+
+import {consoleError} from "../client-log"
+
+import {Acton} from "./Acton"
+import {FormatCommand} from "./ActonCommand"
+
+function isActonUnavailableError(error: unknown): error is NodeJS.ErrnoException {
+    return error instanceof Error && "code" in error && error.code === "ENOENT"
+}
+
+function fullDocumentRange(document: vscode.TextDocument): vscode.Range {
+    const lastLine = document.lineCount - 1
+    const end = document.lineAt(lastLine).range.end
+    return new vscode.Range(new vscode.Position(0, 0), end)
+}
+
+async function resolveWorkingDirectory(document: vscode.TextDocument): Promise<string | undefined> {
+    if (document.uri.scheme === "file") {
+        const actonToml = await Acton.getInstance().findActonToml(document.uri)
+        if (actonToml) {
+            return path.dirname(actonToml.fsPath)
+        }
+
+        const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri)
+        if (workspaceFolder) {
+            return workspaceFolder.uri.fsPath
+        }
+    }
+
+    return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+}
+
+export async function formatTolkDocumentWithActon(
+    document: vscode.TextDocument,
+): Promise<vscode.TextEdit[] | null> {
+    const formatterEnabled = vscode.workspace
+        .getConfiguration("ton", document.uri)
+        .get<boolean>("tolk.formatter.useFormatter", true)
+    if (!formatterEnabled) {
+        return []
+    }
+
+    const source = document.getText()
+    const workingDirectory = await resolveWorkingDirectory(document)
+    const tempDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "acton-fmt-"))
+
+    try {
+        const originalFileName =
+            document.uri.scheme === "file" ? path.basename(document.uri.fsPath) : "untitled.tolk"
+        const tempFilePath = path.join(tempDirectory, originalFileName)
+        await fs.writeFile(tempFilePath, source, "utf8")
+
+        const command = new FormatCommand([tempFilePath])
+        const {exitCode, stderr, stdout} = await Acton.getInstance().spawn(
+            command,
+            workingDirectory,
+        )
+
+        if (exitCode !== 0) {
+            const details = (stderr.trim() || stdout.trim() || `exit code ${exitCode}`).split(
+                "\n",
+            )[0]
+            void vscode.window.showErrorMessage(`Failed to format with acton fmt: ${details}`)
+            return []
+        }
+
+        const formatted = await fs.readFile(tempFilePath, "utf8")
+        if (formatted === source) {
+            return []
+        }
+
+        return [vscode.TextEdit.replace(fullDocumentRange(document), formatted)]
+    } catch (error) {
+        if (isActonUnavailableError(error)) {
+            return null
+        }
+
+        consoleError("Failed to format with acton fmt", error)
+        void vscode.window.showErrorMessage("Failed to format with acton fmt")
+        return []
+    } finally {
+        await fs.rm(tempDirectory, {recursive: true, force: true}).catch(() => {
+            // ignore cleanup errors for temporary files
+        })
+    }
+}

editors/code/src/extension.ts

@@ -54,6 +54,7 @@ import {ActonTomlHoverProvider} from "./acton/toml/ActonTomlHoverProvider"
 import {ActonTolkCodeLensProvider} from "./acton/tolk/ActonTolkCodeLensProvider"
 import {ActonLinter} from "./acton/ActonLinter"
 import {ActonTestController} from "./acton/ActonTestController"
+import {formatTolkDocumentWithActon} from "./acton/ActonFormatter"
 import {configureDebugging} from "./debugging"
 import {ContractData, TransactionRun} from "./providers/sandbox/test-types"
 import {TransactionDetailsInfo} from "./common/types/transaction"
@@ -296,6 +297,28 @@ async function startServer(context: vscode.ExtensionContext): Promise<vscode.Dis
             configurationSection: "ton",
             fileEvents: vscode.workspace.createFileSystemWatcher("**/*.{tolk,fc,func,tlb}"),
         },
+        middleware: {
+            provideDocumentFormattingEdits: async (document, options, token, next) => {
+                if (document.languageId !== "tolk") {
+                    return next(document, options, token)
+                }
+
+                const actonEdits = await formatTolkDocumentWithActon(document)
+                if (actonEdits !== null) {
+                    return actonEdits
+                }
+
+                return next(document, options, token)
+            },
+            provideDocumentRangeFormattingEdits: async (document, range, options, token, next) => {
+                if (document.languageId !== "tolk") {
+                    return next(document, range, options, token)
+                }
+
+                // acton fmt formats whole files only
+                return []
+            },
+        },
         initializationOptions: {
             clientConfig: getClientConfiguration(),
             treeSitterWasmUri: vscode_uri.joinPath(context.extensionUri, "./dist/tree-sitter.wasm")

server/src/languages/tolk/types/ty.ts

@@ -929,7 +929,8 @@ export function joinTypes(left: Ty, right: Ty): Ty {
 // example: `int?` - `null` = `int`
 // example: `int | slice | builder | bool` - `bool | slice` = `int | builder`
 // what for: `if (x != null)` / `if (x is T)`, to smart cast x inside if
-export function subtractTypes(left: Ty | null, right: Ty): Ty {
+export function subtractTypes(left_: Ty | null, right: Ty): Ty {
+    const left = left_?.unwrapAlias()
     if (!left) return NeverTy.NEVER
     if (!(left instanceof UnionTy)) return left