From 3cb1caac7a1ca4ca9eb5f3d6910ddeae3a0b0238 Mon Sep 17 00:00:00 2001 From: i582 <51853996+i582@users.noreply.github.com> Date: Sat, 15 Feb 2025 14:22:33 +0400 Subject: [PATCH] feat(compiler): initial compiler integration Fixes #235 #177 #47 --- client/src/extension.ts | 22 +++++++ package.json | 10 ++++ server/src/server.ts | 22 +++++++ server/src/toolchain/toolchain.ts | 96 +++++++++++++++++++++++++++++++ server/src/utils/settings.ts | 15 +++++ shared/src/shared-msgtypes.ts | 8 +++ 6 files changed, 173 insertions(+) create mode 100644 server/src/toolchain/toolchain.ts diff --git a/client/src/extension.ts b/client/src/extension.ts index c500531c..bd28dec7 100644 --- a/client/src/extension.ts +++ b/client/src/extension.ts @@ -15,6 +15,8 @@ import { GetTypeAtPositionParams, GetTypeAtPositionRequest, GetTypeAtPositionResponse, + SetToolchainVersionNotification, + SetToolchainVersionParams, } from "@shared/shared-msgtypes" import type {Location, Position} from "vscode-languageclient" import type {ClientOptions} from "@shared/config-scheme" @@ -80,6 +82,26 @@ async function startServer(context: vscode.ExtensionContext): Promise { + const settings = vscode.workspace.getConfiguration("tact") + const hash = + settings.get("toolchain.showShortCommitInStatusBar") && + version.version.commit.length > 8 + ? ` (${version.version.commit.slice(-8)})` + : "" + + langStatusBar.text = `Tact ${version.version.number}${hash}` + langStatusBar.show() + }) + return new vscode.Disposable(() => { disposables.forEach(d => void d.dispose()) }) diff --git a/package.json b/package.json index 0190fc04..693f75ce 100644 --- a/package.json +++ b/package.json @@ -131,6 +131,16 @@ "default": null, "description": "Path to Tact standard library. If empty, will try to find in node_modules" }, + "tact.toolchain.compilerPath": { + "type": "string", + "default": "", + "description": "Path to Tact compiler executable. If empty, will try to find in node_modules" + }, + "tact.toolchain.showShortCommitInStatusBar": { + "type": "boolean", + "default": false, + "description": "Add short commit hash after Tact version in status bar" + }, "tact.hints.types": { "type": "boolean", "default": true, diff --git a/server/src/server.ts b/server/src/server.ts index 17255cdc..dde66a8b 100644 --- a/server/src/server.ts +++ b/server/src/server.ts @@ -25,6 +25,8 @@ import { GetTypeAtPositionParams, GetTypeAtPositionRequest, GetTypeAtPositionResponse, + SetToolchainVersionNotification, + SetToolchainVersionParams, } from "@shared/shared-msgtypes" import {KeywordsCompletionProvider} from "./completion/providers/KeywordsCompletionProvider" import type {CompletionProvider} from "./completion/CompletionProvider" @@ -111,6 +113,7 @@ import { WrapSelectedToTryCatch, } from "@server/intentions/WrapSelected" import {PostfixCompletionProvider} from "@server/completion/providers/PostfixCompletionProvider" +import {Toolchain, InvalidToolchainError, fallbackToolchain} from "@server/toolchain/toolchain" /** * Whenever LS is initialized. @@ -120,6 +123,8 @@ import {PostfixCompletionProvider} from "@server/completion/providers/PostfixCom */ let initialized = false +let toolchain: Toolchain = fallbackToolchain + let clientInfo: {name?: string; version?: string} = {name: "", version: ""} /** @@ -184,6 +189,23 @@ async function initialize(): Promise { const settings = await getDocumentSettings(rootUri) + try { + toolchain = + settings.toolchain.compilerPath === "" + ? Toolchain.autoDetect(rootDir) + : Toolchain.fromPath(settings.toolchain.compilerPath) + console.info(`using toolchain ${toolchain.toString()}`) + + await connection.sendNotification(SetToolchainVersionNotification, { + version: toolchain.version, + } satisfies SetToolchainVersionParams) + } catch (error) { + if (error instanceof InvalidToolchainError) { + console.info(`toolchain is invalid ${error.message}`) + showErrorMessage(error.message) + } + } + const stdlibPath = findStdlib(settings, rootDir) if (stdlibPath !== null) { reporter.report(50, "Indexing: (1/3) Standard Library") diff --git a/server/src/toolchain/toolchain.ts b/server/src/toolchain/toolchain.ts new file mode 100644 index 00000000..27060732 --- /dev/null +++ b/server/src/toolchain/toolchain.ts @@ -0,0 +1,96 @@ +import * as path from "node:path" +import * as cp from "node:child_process" +import {SpawnSyncReturns} from "node:child_process" +import {existsSync} from "node:fs" +import * as console from "node:console" + +export class InvalidToolchainError extends Error { + public constructor(message: string) { + super(message) + this.name = "InvalidToolchainError" + } +} + +export class Toolchain { + public readonly compilerPath: string + public version: { + number: string + commit: string + } + + public constructor(compilerPath: string) { + this.compilerPath = compilerPath + this.version = { + number: "", + commit: "", + } + } + + public static autoDetect(root: string): Toolchain { + const defaultPath = path.join(root, "node_modules", ".bin", "tact") + if (!existsSync(defaultPath)) { + console.info(`cannot find toolchain in default directory: ${defaultPath}`) + return fallbackToolchain + } + + return new Toolchain(defaultPath).setVersion() + } + + public static fromPath(path: string): Toolchain { + return new Toolchain(path).validate() + } + + private setVersion(): this { + try { + const result = cp.execSync(`${this.compilerPath} -v`) + const rawVersion = result.toString() + const lines = rawVersion.split("\n") + + this.version = { + number: lines[0] ?? "", + commit: lines[1] ?? "", + } + } catch { + // ignore errors here for now + } + return this + } + + private validate(): this { + try { + const result = cp.execSync(`${this.compilerPath} -v`) + const rawVersion = result.toString() + const lines = rawVersion.split("\n") + + this.version = { + number: lines[0] ?? "", + commit: lines[1] ?? "", + } + } catch (error_: unknown) { + const error = error_ as SpawnSyncReturns + + console.log(error.stdout.toString()) + console.log(error.stderr.toString()) + + const tip = `Please recheck path or leave it empty to LS find toolchain automatically` + + if (error.stderr.includes("not found")) { + throw new InvalidToolchainError( + `Cannot find valid Tact executable in "${this.compilerPath}"! ${tip}`, + ) + } + + throw new InvalidToolchainError( + `Path ${this.compilerPath} is invalid! ${tip}: ${error.stderr.toString()}`, + ) + } + + return this + } + + public toString(): string { + return `Toolchain(path=${this.compilerPath}, version=${this.version.number}:${this.version.commit})` + } +} + +export const fallbackToolchain = new Toolchain("fallback-toolchain") diff --git a/server/src/utils/settings.ts b/server/src/utils/settings.ts index ce6451ec..86377fc2 100644 --- a/server/src/utils/settings.ts +++ b/server/src/utils/settings.ts @@ -6,6 +6,10 @@ export interface TactSettings { stdlib: { path: string | null } + toolchain: { + compilerPath: string + showShortCommitInStatusBar: boolean + } findUsages: { scope: FindUsagesScope } @@ -54,6 +58,10 @@ const defaultSettings: TactSettings = { stdlib: { path: null, }, + toolchain: { + compilerPath: "", + showShortCommitInStatusBar: false, + }, findUsages: { scope: "workspace", }, @@ -105,6 +113,13 @@ function mergeSettings(vsSettings: Partial): TactSettings { stdlib: { path: vsSettings.stdlib?.path ?? defaultSettings.stdlib.path, }, + toolchain: { + compilerPath: + vsSettings.toolchain?.compilerPath ?? defaultSettings.toolchain.compilerPath, + showShortCommitInStatusBar: + vsSettings.toolchain?.showShortCommitInStatusBar ?? + defaultSettings.toolchain.showShortCommitInStatusBar, + }, findUsages: { scope: vsSettings.findUsages?.scope ?? defaultSettings.findUsages.scope, }, diff --git a/shared/src/shared-msgtypes.ts b/shared/src/shared-msgtypes.ts index 66090676..41e71bc0 100644 --- a/shared/src/shared-msgtypes.ts +++ b/shared/src/shared-msgtypes.ts @@ -2,6 +2,7 @@ import type * as lsp from "vscode-languageserver" export const GetTypeAtPositionRequest = "tact/getTypeAtPosition" export const GetDocumentationAtPositionRequest = "tact/executeHoverProvider" +export const SetToolchainVersionNotification = "tact/setToolchainVersion" export interface GetTypeAtPositionParams { textDocument: { @@ -13,6 +14,13 @@ export interface GetTypeAtPositionParams { } } +export interface SetToolchainVersionParams { + version: { + number: string + commit: string + } +} + export interface GetTypeAtPositionResponse { type: string | null }