feat(tolk): support mappings from Tolk 1.3

Fixes #264

Author: i582

server/src/acton/ActonToml.ts

@@ -2,11 +2,10 @@
 //  Copyright © 2026 TON Core
 
 import * as path from "node:path"
+import * as fs from "node:fs"
 
 import {URI} from "vscode-uri"
 
-import {readFileVFS, globalVFS, existsVFS} from "@server/vfs/files-adapter"
-
 export interface WalletInfo {
     readonly name: string
     readonly isLocal: boolean
@@ -15,12 +14,17 @@ export interface WalletInfo {
 export class ActonToml {
     public constructor(private readonly uri: string) {}
 
-    private async readContent(uri: string): Promise<string | undefined> {
-        return readFileVFS(globalVFS, uri)
+    private readContent(uri: string): string | undefined {
+        try {
+            const fsPath = URI.parse(uri).fsPath
+            return fs.readFileSync(fsPath, "utf8")
+        } catch {
+            return undefined
+        }
     }
 
-    public async getContractIds(): Promise<string[]> {
-        const content = await this.readContent(this.uri)
+    public getContractIds(): string[] {
+        const content = this.readContent(this.uri)
         if (!content) return []
 
         const contractIds: string[] = []
@@ -36,38 +40,59 @@ export class ActonToml {
         return contractIds
     }
 
-    public async getWallets(): Promise<WalletInfo[]> {
+    public getMappings(): Map<string, string> {
+        const content = this.readContent(this.uri)
+        if (!content) return new Map()
+
+        const mappings: Map<string, string> = new Map()
+        // Simple manual parsing for [mappings] table
+        const lines = content.split("\n")
+        let inMappings = false
+        for (const line of lines) {
+            const trimmed = line.trim()
+            if (trimmed === "[mappings]") {
+                inMappings = true
+                continue
+            }
+            if (trimmed.startsWith("[") && trimmed !== "[mappings]") {
+                inMappings = false
+                continue
+            }
+            if (inMappings && trimmed.includes("=")) {
+                const [rawKey, rawValue] = trimmed.split("=").map(s => s.trim())
+                if (rawKey && rawValue) {
+                    // remove quotes from key and then @ prefix
+                    const cleanKey = rawKey.replace(/^["']|["']$/g, "")
+                    const key = cleanKey.startsWith("@") ? cleanKey.slice(1) : cleanKey
+                    // remove quotes from value
+                    const cleanValue = rawValue.replace(/^["']|["']$/g, "")
+                    mappings.set(key, cleanValue)
+                }
+            }
+        }
+        return mappings
+    }
+
+    public get workingDir(): string {
+        return path.dirname(URI.parse(this.uri).fsPath)
+    }
+
+    public getWallets(): WalletInfo[] {
         const wallets: WalletInfo[] = []
 
         const baseUri = URI.parse(this.uri)
         const dirPath = path.dirname(baseUri.fsPath)
 
         const walletsTomlUri = URI.file(path.join(dirPath, "wallets.toml")).toString()
-        const walletsContent = await this.readContent(walletsTomlUri)
+        const walletsContent = this.readContent(walletsTomlUri)
         if (walletsContent) {
-            // Match [wallets.NAME] where NAME does not contain a dot
-            const walletRegex = /^\[wallets\.([^\s.\]]+)]/gm
-            let match: RegExpExecArray | null
-            while ((match = walletRegex.exec(walletsContent)) !== null) {
-                const name = match[1]
-                if (name) {
-                    wallets.push({name, isLocal: true})
-                }
-            }
+            wallets.push(...this.parseWallets(walletsContent, true))
         }
 
         const globalWalletsTomlUri = URI.file(path.join(dirPath, "global.wallets.toml")).toString()
-        const globalWalletsContent = await this.readContent(globalWalletsTomlUri)
+        const globalWalletsContent = this.readContent(globalWalletsTomlUri)
         if (globalWalletsContent) {
-            // Match [wallets.NAME] where NAME does not contain a dot
-            const walletRegex = /^\[wallets\.([^\s.\]]+)]/gm
-            let match: RegExpExecArray | null
-            while ((match = walletRegex.exec(globalWalletsContent)) !== null) {
-                const name = match[1]
-                if (name) {
-                    wallets.push({name, isLocal: false})
-                }
-            }
+            wallets.push(...this.parseWallets(globalWalletsContent, false))
         }
 
         const seen: Set<string> = new Set()
@@ -78,15 +103,29 @@ export class ActonToml {
         })
     }
 
-    public static async find(startUri: string): Promise<ActonToml | undefined> {
+    private parseWallets(content: string, isLocal: boolean): WalletInfo[] {
+        const wallets: WalletInfo[] = []
+        // Match [wallets.NAME] where NAME does not contain a dot
+        const walletRegex = /^\[wallets\.([^\s.\]]+)]/gm
+        let match: RegExpExecArray | null
+        while ((match = walletRegex.exec(content)) !== null) {
+            const name = match[1]
+            if (name) {
+                wallets.push({name, isLocal})
+            }
+        }
+        return wallets
+    }
+
+    public static discover(startUri: string): ActonToml | undefined {
         let currentPath = URI.parse(startUri).fsPath
 
         for (let i = 0; i < 10; i++) {
             const dir = path.dirname(currentPath)
             const tomlPath = path.join(dir, "Acton.toml")
-            const tomlUri = URI.file(tomlPath).toString()
 
-            if (await existsVFS(globalVFS, tomlUri)) {
+            if (fs.existsSync(tomlPath)) {
+                const tomlUri = URI.file(tomlPath).toString()
                 return new ActonToml(tomlUri)
             }
 

server/src/languages/tolk/completion/index.ts

@@ -126,19 +126,18 @@ export async function provideTolkCompletion(
         new StructFieldModifiersCompletionProvider(),
         new EnumCompletionProvider(),
         new ContractFieldCompletionProvider(),
+        new ActonWalletNameCompletionProvider(),
+        new ActonContractIdCompletionProvider(),
+        new ImportPathCompletionProvider(),
+        new ActonGetMethodCompletionProvider(),
     ]
 
     for (const provider of providers) {
         if (!provider.isAvailable(ctx)) continue
         provider.addCompletion(ctx, result)
     }
 
-    const asyncProviders: AsyncCompletionProvider<CompletionContext>[] = [
-        new ImportPathCompletionProvider(),
-        new ActonWalletNameCompletionProvider(),
-        new ActonContractIdCompletionProvider(),
-        new ActonGetMethodCompletionProvider(),
-    ]
+    const asyncProviders: AsyncCompletionProvider<CompletionContext>[] = []
 
     for (const provider of asyncProviders) {
         if (!provider.isAvailable(ctx)) continue

server/src/languages/tolk/completion/providers/ActonContractIdCompletionProvider.ts

@@ -18,14 +18,11 @@ export class ActonContractIdCompletionProvider extends ActonStringArgumentComple
         return functionName === "build" && qualifierName === undefined && argumentIndex === 0
     }
 
-    protected async addStringCompletions(
-        ctx: CompletionContext,
-        result: CompletionResult,
-    ): Promise<void> {
-        const actonToml = await ActonToml.find(ctx.element.file.uri)
+    protected addStringCompletions(ctx: CompletionContext, result: CompletionResult): void {
+        const actonToml = ActonToml.discover(ctx.element.file.uri)
         if (!actonToml) return
 
-        const contractIds = await actonToml.getContractIds()
+        const contractIds = actonToml.getContractIds()
         for (const id of contractIds) {
             result.add({
                 label: id,

server/src/languages/tolk/completion/providers/ActonGetMethodCompletionProvider.ts

@@ -22,11 +22,7 @@ export class ActonGetMethodCompletionProvider extends ActonStringArgumentComplet
         return functionName === "runGetMethod" && qualifierName === "net" && argumentIndex === 1
     }
 
-    protected async addStringCompletions(
-        _ctx: CompletionContext,
-        result: CompletionResult,
-    ): Promise<void> {
-        await Promise.resolve()
+    protected addStringCompletions(_ctx: CompletionContext, result: CompletionResult): void {
         const getMethods: GetMethod[] = []
         index.processElementsByKey(
             IndexKey.GetMethods,

server/src/languages/tolk/completion/providers/ActonStringArgumentCompletionProvider.ts

@@ -1,18 +1,18 @@
 //  SPDX-License-Identifier: MIT
 //  Copyright © 2026 TON Core
 
-import {AsyncCompletionProvider} from "@server/completion/CompletionProvider"
+import {CompletionProvider} from "@server/completion/CompletionProvider"
 import {CompletionContext} from "@server/languages/tolk/completion/CompletionContext"
 import {CompletionResult} from "@server/completion/WeightedCompletionItem"
 
 export abstract class ActonStringArgumentCompletionProvider
-    implements AsyncCompletionProvider<CompletionContext>
+    implements CompletionProvider<CompletionContext>
 {
     public isAvailable(ctx: CompletionContext): boolean {
         return ctx.insideString
     }
 
-    public async addCompletion(ctx: CompletionContext, result: CompletionResult): Promise<void> {
+    public addCompletion(ctx: CompletionContext, result: CompletionResult): void {
         const node = ctx.element.node
         let parent = node.parent
         if (parent && parent.type === "call_argument") {
@@ -50,7 +50,7 @@ export abstract class ActonStringArgumentCompletionProvider
         const argIndex = args.findIndex(arg => arg?.id === parent.id)
 
         if (this.shouldAddCompletions(functionName, qualifierName, argIndex)) {
-            await this.addStringCompletions(ctx, result, functionName, qualifierName, argIndex)
+            this.addStringCompletions(ctx, result, functionName, qualifierName, argIndex)
         }
     }
 
@@ -66,5 +66,5 @@ export abstract class ActonStringArgumentCompletionProvider
         functionName: string,
         qualifierName: string | undefined,
         argumentIndex: number,
-    ): Promise<void>
+    ): void
 }

server/src/languages/tolk/completion/providers/ActonWalletNameCompletionProvider.ts

@@ -18,14 +18,11 @@ export class ActonWalletNameCompletionProvider extends ActonStringArgumentComple
         return functionName === "wallet" && qualifierName === "net" && argumentIndex === 0
     }
 
-    protected async addStringCompletions(
-        ctx: CompletionContext,
-        result: CompletionResult,
-    ): Promise<void> {
-        const actonToml = await ActonToml.find(ctx.element.file.uri)
+    protected addStringCompletions(ctx: CompletionContext, result: CompletionResult): void {
+        const actonToml = ActonToml.discover(ctx.element.file.uri)
         if (!actonToml) return
 
-        const wallets = await actonToml.getWallets()
+        const wallets = actonToml.getWallets()
         for (const wallet of wallets) {
             result.add({
                 label: wallet.name,