lean4monaco 1.0.45 → 1.1.0

package/dist/monaco-lean4/vscode-lean4/src/taskgutter.js

@@ -0,0 +1,130 @@
+import { LeanFileProgressKind } from '@leanprover/infoview-api';
+import { OverviewRulerLane, Range, window } from 'vscode';
+class LeanFileTaskGutter {
+    uri;
+    decorations;
+    processed;
+    timeout;
+    constructor(uri, decorations, processed) {
+        this.uri = uri;
+        this.decorations = decorations;
+        this.processed = processed;
+        this.schedule(100);
+    }
+    setProcessed(processed) {
+        if (processed === this.processed)
+            return;
+        const oldProcessed = this.processed;
+        this.processed = processed;
+        if (processed === undefined) {
+            this.processed = [];
+            this.clearTimeout();
+            this.updateDecos();
+        }
+        else if (this.timeout === undefined) {
+            this.schedule(oldProcessed === undefined ? 500 : 20);
+        }
+    }
+    schedule(ms) {
+        this.timeout = setTimeout(() => {
+            this.timeout = undefined;
+            this.updateDecos();
+        }, ms);
+    }
+    clearTimeout() {
+        if (this.timeout !== undefined) {
+            clearTimeout(this.timeout);
+            this.timeout = undefined;
+        }
+    }
+    updateDecos() {
+        for (const editor of window.visibleTextEditors) {
+            if (editor.document.uri.toString() === this.uri) {
+                for (const [kind, [decoration, message]] of this.decorations) {
+                    editor.setDecorations(decoration, this.processed
+                        .filter(info => (info.kind === undefined ? LeanFileProgressKind.Processing : info.kind) === kind)
+                        .map(info => ({
+                        range: new Range(info.range.start.line, 0, info.range.end.line, 0),
+                        hoverMessage: message,
+                    })));
+                }
+            }
+        }
+    }
+    dispose() {
+        this.clearTimeout();
+    }
+}
+export class LeanTaskGutter {
+    decorations = new Map();
+    status = {};
+    gutters = {};
+    subscriptions = [];
+    constructor(client, context) {
+        this.decorations.set(LeanFileProgressKind.Processing, [
+            window.createTextEditorDecorationType({
+                overviewRulerLane: OverviewRulerLane.Left,
+                overviewRulerColor: 'rgba(255, 165, 0, 0.5)',
+                dark: {
+                    gutterIconPath: context.asAbsolutePath('media/progress-dark.svg'),
+                },
+                light: {
+                    gutterIconPath: context.asAbsolutePath('media/progress-light.svg'),
+                },
+                gutterIconSize: 'contain',
+            }),
+            'busily processing...',
+        ]);
+        this.decorations.set(LeanFileProgressKind.FatalError, [
+            window.createTextEditorDecorationType({
+                overviewRulerLane: OverviewRulerLane.Left,
+                overviewRulerColor: 'rgba(255, 0, 0, 0.5)',
+                dark: {
+                    gutterIconPath: context.asAbsolutePath('media/progress-error-dark.svg'),
+                },
+                light: {
+                    gutterIconPath: context.asAbsolutePath('media/progress-error-light.svg'),
+                },
+                gutterIconSize: 'contain',
+            }),
+            'processing stopped',
+        ]);
+        this.subscriptions.push(window.onDidChangeVisibleTextEditors(() => this.updateDecos()), client.progressChanged(([uri, processing]) => {
+            this.status[uri] = processing;
+            this.updateDecos();
+        }));
+    }
+    updateDecos() {
+        const uris = {};
+        for (const editor of window.visibleTextEditors) {
+            if (editor.document.languageId !== 'lean4')
+                continue;
+            const uri = editor.document.uri.toString();
+            uris[uri] = true;
+            const processed = uri in this.status ? this.status[uri] : [];
+            if (this.gutters[uri]) {
+                const gutter = this.gutters[uri];
+                if (gutter)
+                    gutter.setProcessed(processed);
+            }
+            else {
+                this.gutters[uri] = new LeanFileTaskGutter(uri, this.decorations, processed);
+            }
+        }
+        for (const uri of Object.getOwnPropertyNames(this.gutters)) {
+            if (!uris[uri]) {
+                this.gutters[uri]?.dispose();
+                this.gutters[uri] = undefined;
+                // TODO: also clear this.status for this uri ?
+            }
+        }
+    }
+    dispose() {
+        for (const [decoration, _message] of this.decorations.values()) {
+            decoration.dispose();
+        }
+        for (const s of this.subscriptions) {
+            s.dispose();
+        }
+    }
+}

package/dist/{vscode-lean4/vscode-lean4/src/utils/batchBasics.d.ts → monaco-lean4/vscode-lean4/src/utils/batch.d.ts}

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import { ChildProcessWithoutNullStreams } from 'child_process';
 import { OutputChannel } from 'vscode';
 export interface ExecutionChannel {
     combined?: OutputChannel | undefined;
@@ -16,25 +18,20 @@ export interface ExecutionResult {
     stderr: string;
     combined: string;
 }
-export declare function createCannotLaunchExecutionResult(message: string): ExecutionResult;
-export interface ProgressExecutionOptions {
+export declare function batchExecuteWithProc(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined): [ChildProcessWithoutNullStreams | 'CannotLaunch', Promise<ExecutionResult>];
+export declare function batchExecute(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined): Promise<ExecutionResult>;
+interface ProgressExecutionOptions {
     cwd?: string | undefined;
     channel?: OutputChannel | undefined;
     translator?: ((line: string) => string | undefined) | undefined;
-    envExtensions?: {
-        [key: string]: string;
-    } | undefined;
     allowCancellation?: boolean;
 }
-export type ExecutionHandler = () => Promise<ExecutionResult>;
+export declare function batchExecuteWithProgress(executablePath: string, args: string[], title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;
+type ExecutionHandler = () => Promise<ExecutionResult>;
 export interface BatchExecution {
     execute: ExecutionHandler;
     optional?: boolean | undefined;
 }
 export declare function executeAll(executions: BatchExecution[]): Promise<ExecutionResult[]>;
 export declare function displayResultError(result: ExecutionResult, message: string): void;
-export declare function formatErrorMessage(error: ExecutionResult, message: string): string;
-export declare function batchExecuteDummy(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined, envExtensions?: {
-    [key: string]: string;
-} | undefined): Promise<ExecutionResult>;
-export declare function batchExecuteWithProgressDummy(executablePath: string, args: string[], context: string | undefined, title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;
+export {};

package/dist/monaco-lean4/vscode-lean4/src/utils/batch.js

@@ -0,0 +1,203 @@
+import { spawn } from 'child_process';
+import { ProgressLocation, window } from 'vscode';
+import { logger } from './logger';
+import { displayErrorWithOutput } from './notifs';
+export var ExecutionExitCode;
+(function (ExecutionExitCode) {
+    ExecutionExitCode[ExecutionExitCode["Success"] = 0] = "Success";
+    ExecutionExitCode[ExecutionExitCode["CannotLaunch"] = 1] = "CannotLaunch";
+    ExecutionExitCode[ExecutionExitCode["ExecutionError"] = 2] = "ExecutionError";
+    ExecutionExitCode[ExecutionExitCode["Cancelled"] = 3] = "Cancelled";
+})(ExecutionExitCode || (ExecutionExitCode = {}));
+function createCannotLaunchExecutionResult(message) {
+    return {
+        exitCode: ExecutionExitCode.CannotLaunch,
+        stdout: message,
+        stderr: '',
+        combined: message,
+    };
+}
+export function batchExecuteWithProc(executablePath, args, workingDirectory, channel) {
+    let stdout = '';
+    let stderr = '';
+    let combined = '';
+    let options = {};
+    if (workingDirectory !== undefined) {
+        options = { cwd: workingDirectory };
+    }
+    if (channel?.combined) {
+        const formattedCwd = workingDirectory ? `${workingDirectory}` : '';
+        const formattedArgs = args.map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
+        channel.combined.appendLine(`${formattedCwd}> ${executablePath} ${formattedArgs}`);
+    }
+    let proc;
+    try {
+        proc = spawn(executablePath, args, options);
+    }
+    catch (e) {
+        return ['CannotLaunch', new Promise(resolve => resolve(createCannotLaunchExecutionResult('')))];
+    }
+    const execPromise = new Promise(resolve => {
+        const conclude = (r) => resolve({
+            exitCode: r.exitCode,
+            stdout: r.stdout.trim(),
+            stderr: r.stderr.trim(),
+            combined: r.combined.trim(),
+        });
+        proc.on('error', err => {
+            conclude(createCannotLaunchExecutionResult(err.message));
+        });
+        proc.stdout.on('data', line => {
+            const s = line.toString();
+            if (channel?.combined)
+                channel.combined.appendLine(s);
+            if (channel?.stdout)
+                channel.stdout.appendLine(s);
+            stdout += s + '\n';
+            combined += s + '\n';
+        });
+        proc.stderr.on('data', line => {
+            const s = line.toString();
+            if (channel?.combined)
+                channel.combined.appendLine(s);
+            if (channel?.stderr)
+                channel.stderr.appendLine(s);
+            stderr += s + '\n';
+            combined += s + '\n';
+        });
+        proc.on('close', (code, signal) => {
+            logger.log(`child process exited with code ${code}`);
+            if (signal === 'SIGTERM') {
+                if (channel?.combined) {
+                    channel.combined.appendLine('=> Operation cancelled by user.');
+                }
+                conclude({
+                    exitCode: ExecutionExitCode.Cancelled,
+                    stdout,
+                    stderr,
+                    combined,
+                });
+                return;
+            }
+            if (code !== 0) {
+                if (channel?.combined) {
+                    const formattedCode = code ? `Exit code: ${code}.` : '';
+                    const formattedSignal = signal ? `Signal: ${signal}.` : '';
+                    channel.combined.appendLine(`=> Operation failed. ${formattedCode} ${formattedSignal}`.trim());
+                }
+                conclude({
+                    exitCode: ExecutionExitCode.ExecutionError,
+                    stdout,
+                    stderr,
+                    combined,
+                });
+                return;
+            }
+            conclude({
+                exitCode: ExecutionExitCode.Success,
+                stdout,
+                stderr,
+                combined,
+            });
+        });
+    });
+    return [proc, execPromise];
+}
+export async function batchExecute(executablePath, args, workingDirectory, channel) {
+    const [_, execPromise] = batchExecuteWithProc(executablePath, args, workingDirectory, channel);
+    return execPromise;
+}
+export async function batchExecuteWithProgress(executablePath, args, title, options = {}) {
+    const titleSuffix = options.channel ? ' [(Details)](command:lean4.troubleshooting.showOutput)' : '';
+    const progressOptions = {
+        location: ProgressLocation.Notification,
+        title: title + titleSuffix,
+        cancellable: options.allowCancellation === true,
+    };
+    let inc = 0;
+    let lastReportedMessage;
+    let progress;
+    const progressChannel = {
+        name: 'ProgressChannel',
+        append(value) {
+            if (options.translator) {
+                const translatedValue = options.translator(value);
+                if (translatedValue === undefined) {
+                    return;
+                }
+                value = translatedValue;
+            }
+            if (options.channel) {
+                options.channel.appendLine(value.trimEnd());
+            }
+            if (inc < 90) {
+                inc += 2;
+            }
+            if (progress !== undefined) {
+                progress.report({ increment: inc, message: value });
+            }
+            lastReportedMessage = value;
+        },
+        appendLine(value) {
+            this.append(value + '\n');
+        },
+        replace(_) {
+            /* empty */
+        },
+        clear() {
+            /* empty */
+        },
+        show() {
+            /* empty */
+        },
+        hide() {
+            /* empty */
+        },
+        dispose() {
+            /* empty */
+        },
+    };
+    const expensiveExecutionTimeoutPromise = new Promise((resolve, _) => setTimeout(() => resolve(undefined), 250));
+    const [proc, executionPromise] = batchExecuteWithProc(executablePath, args, options.cwd, {
+        combined: progressChannel,
+    });
+    if (proc === 'CannotLaunch') {
+        return executionPromise; // resolves to a 'CannotLaunch' ExecutionResult
+    }
+    const preliminaryResult = await Promise.race([expensiveExecutionTimeoutPromise, executionPromise]);
+    if (preliminaryResult !== undefined) {
+        return preliminaryResult;
+    }
+    // Execution already took longer than 250ms, let's start displaying a progress bar now
+    const result = await window.withProgress(progressOptions, (p, token) => {
+        progress = p;
+        token.onCancellationRequested(() => proc.kill());
+        progress.report({ message: lastReportedMessage, increment: inc });
+        return executionPromise;
+    });
+    return result;
+}
+export async function executeAll(executions) {
+    const results = [];
+    for (const execution of executions) {
+        const result = await execution.execute();
+        results.push(result);
+        if (execution.optional !== true && result.exitCode !== ExecutionExitCode.Success) {
+            break;
+        }
+    }
+    return results;
+}
+export function displayResultError(result, message) {
+    if (result.exitCode === ExecutionExitCode.Success) {
+        throw Error();
+    }
+    const errorMessage = formatErrorMessage(result, message);
+    displayErrorWithOutput(errorMessage);
+}
+function formatErrorMessage(error, message) {
+    if (error.combined === '') {
+        return `${message}`;
+    }
+    return `${message} Command output: ${error.combined}`;
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/clientProvider.d.ts

@@ -0,0 +1,41 @@
+import { LeanFileProgressProcessingInfo, ServerStoppedReason } from '@leanprover/infoview-api';
+import { Disposable, OutputChannel, TextDocument } from 'vscode';
+import { PreconditionCheckResult } from '../diagnostics/setupNotifs';
+import { LeanClient } from '../leanclient';
+import { ExtUri } from './exturi';
+import { LeanInstaller } from './leanInstaller';
+import { BaseLanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
+export declare class LeanClientProvider implements Disposable {
+    private setupClient;
+    private checkLean4ProjectPreconditions;
+    private isOpenLeanDocument;
+    private subscriptions;
+    private outputChannel;
+    private installer;
+    private clients;
+    private pending;
+    private pendingInstallChanged;
+    private processingInstallChanged;
+    private activeClient;
+    private progressChangedEmitter;
+    progressChanged: import("vscode").Event<[string, LeanFileProgressProcessingInfo[]]>;
+    private clientAddedEmitter;
+    clientAdded: import("vscode").Event<LeanClient>;
+    private clientRemovedEmitter;
+    clientRemoved: import("vscode").Event<LeanClient>;
+    private clientStoppedEmitter;
+    clientStopped: import("vscode").Event<[LeanClient, boolean, ServerStoppedReason]>;
+    constructor(installer: LeanInstaller, outputChannel: OutputChannel, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>, checkLean4ProjectPreconditions: (channel: OutputChannel, folderUri: ExtUri) => Promise<PreconditionCheckResult>, isOpenLeanDocument: (docUri: ExtUri) => boolean);
+    getActiveClient(): LeanClient | undefined;
+    private onInstallChanged;
+    private restartFile;
+    private stopActiveClient;
+    private restartActiveClient;
+    clientIsStarted(): void;
+    didOpenEditor(document: TextDocument): Promise<void>;
+    findClient(path: ExtUri): LeanClient | undefined;
+    getClients(): LeanClient[];
+    getClientForFolder(folder: ExtUri): LeanClient | undefined;
+    ensureClient(uri: ExtUri): Promise<[boolean, LeanClient | undefined]>;
+    dispose(): void;
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/clientProvider.js

@@ -0,0 +1,205 @@
+import { EventEmitter, commands, window, workspace } from 'vscode';
+import { LeanClient } from '../leanclient';
+import { UntitledUri, getWorkspaceFolderUri, toExtUri } from './exturi';
+import { logger } from './logger';
+import { displayError } from './notifs';
+import { findLeanProjectRoot } from './projectInfo';
+// This class ensures we have one LeanClient per folder.
+export class LeanClientProvider {
+    setupClient;
+    checkLean4ProjectPreconditions;
+    isOpenLeanDocument;
+    subscriptions = [];
+    outputChannel;
+    installer;
+    clients = new Map();
+    pending = new Map();
+    pendingInstallChanged = [];
+    processingInstallChanged = false;
+    activeClient = undefined;
+    progressChangedEmitter = new EventEmitter();
+    progressChanged = this.progressChangedEmitter.event;
+    clientAddedEmitter = new EventEmitter();
+    clientAdded = this.clientAddedEmitter.event;
+    clientRemovedEmitter = new EventEmitter();
+    clientRemoved = this.clientRemovedEmitter.event;
+    clientStoppedEmitter = new EventEmitter();
+    clientStopped = this.clientStoppedEmitter.event;
+    constructor(installer, outputChannel, setupClient, checkLean4ProjectPreconditions, isOpenLeanDocument) {
+        this.setupClient = setupClient;
+        this.checkLean4ProjectPreconditions = checkLean4ProjectPreconditions;
+        this.isOpenLeanDocument = isOpenLeanDocument;
+        this.outputChannel = outputChannel;
+        this.installer = installer;
+        // we must setup the installChanged event handler first before any didOpenEditor calls.
+        this.subscriptions.push(installer.installChanged(async (uri) => await this.onInstallChanged(uri)));
+        window.visibleTextEditors.forEach(e => this.didOpenEditor(e.document));
+        this.subscriptions.push(window.onDidChangeActiveTextEditor(async (e) => {
+            if (!e) {
+                return;
+            }
+            await this.didOpenEditor(e.document);
+        }));
+        this.subscriptions.push(commands.registerCommand('lean4.restartFile', () => this.restartFile()), commands.registerCommand('lean4.refreshFileDependencies', () => this.restartFile()), commands.registerCommand('lean4.restartServer', () => this.restartActiveClient()), commands.registerCommand('lean4.stopServer', () => this.stopActiveClient()));
+        this.subscriptions.push(workspace.onDidOpenTextDocument(document => this.didOpenEditor(document)));
+        this.subscriptions.push(workspace.onDidChangeWorkspaceFolders(event => {
+            // Remove all clients that are not referenced by any folder anymore
+            if (event.removed.length === 0) {
+                return;
+            }
+            this.clients.forEach((client, key) => {
+                if (client.folderUri.scheme === 'untitled' || getWorkspaceFolderUri(client.folderUri)) {
+                    return;
+                }
+                logger.log(`[ClientProvider] onDidChangeWorkspaceFolders removing client for ${key}`);
+                this.clients.delete(key);
+                client.dispose();
+                this.clientRemovedEmitter.fire(client);
+            });
+        }));
+    }
+    getActiveClient() {
+        return this.activeClient;
+    }
+    async onInstallChanged(uri) {
+        // Uri is a package Uri in the case a lean package file was changed.
+        logger.log(`[ClientProvider] installChanged for ${uri}`);
+        this.pendingInstallChanged.push(uri);
+        if (this.processingInstallChanged) {
+            // avoid re-entrancy.
+            return;
+        }
+        this.processingInstallChanged = true;
+        while (true) {
+            const uri = this.pendingInstallChanged.pop();
+            if (!uri) {
+                break;
+            }
+            try {
+                const projectUri = await findLeanProjectRoot(uri);
+                const preconditionCheckResult = await this.checkLean4ProjectPreconditions(this.outputChannel, projectUri);
+                if (preconditionCheckResult !== 'Fatal') {
+                    logger.log('[ClientProvider] got lean version 4');
+                    const [cached, client] = await this.ensureClient(uri);
+                    if (cached && client) {
+                        await client.restart();
+                        logger.log('[ClientProvider] restart complete');
+                    }
+                }
+            }
+            catch (e) {
+                logger.log(`[ClientProvider] Exception checking lean version: ${e}`);
+            }
+        }
+        this.processingInstallChanged = false;
+    }
+    restartFile() {
+        if (!this.activeClient || !this.activeClient.isRunning()) {
+            displayError('No active client.');
+            return;
+        }
+        if (!window.activeTextEditor || window.activeTextEditor.document.languageId !== 'lean4') {
+            displayError('No active Lean editor tab. Make sure to focus the Lean editor tab for which you want to issue a restart.');
+            return;
+        }
+        void this.activeClient.restartFile(window.activeTextEditor.document);
+    }
+    stopActiveClient() {
+        if (this.activeClient && this.activeClient.isStarted()) {
+            void this.activeClient?.stop();
+        }
+    }
+    async restartActiveClient() {
+        void this.activeClient?.restart();
+    }
+    clientIsStarted() {
+        void this.activeClient?.isStarted();
+    }
+    async didOpenEditor(document) {
+        // bail as quickly as possible on non-lean files.
+        if (document.languageId !== 'lean4') {
+            return;
+        }
+        const uri = toExtUri(document.uri);
+        if (uri === undefined) {
+            return;
+        }
+        await this.ensureClient(uri);
+    }
+    // Find the client for a given document.
+    findClient(path) {
+        const candidates = this.getClients().filter(client => client.isInFolderManagedByThisClient(path));
+        // All candidate folders are a prefix of `path`, so they must necessarily be prefixes of one another
+        // => the best candidate (the most top-level client folder) is just the one with the shortest path
+        let bestCandidate;
+        for (const candidate of candidates) {
+            if (!bestCandidate) {
+                bestCandidate = candidate;
+                continue;
+            }
+            const folder = candidate.getClientFolder();
+            const bestFolder = bestCandidate.getClientFolder();
+            if (folder.scheme === 'file' &&
+                bestFolder.scheme === 'file' &&
+                folder.fsPath.length < bestFolder.fsPath.length) {
+                bestCandidate = candidate;
+            }
+        }
+        return bestCandidate;
+    }
+    getClients() {
+        return Array.from(this.clients.values());
+    }
+    getClientForFolder(folder) {
+        return this.clients.get(folder.toString());
+    }
+    // Starts a LeanClient if the given file is in a new workspace we haven't seen before.
+    // Returns a boolean "true" if the LeanClient was already created.
+    // Returns a null client if it turns out the new workspace is a lean3 workspace.
+    async ensureClient(uri) {
+        const folderUri = uri.scheme === 'file' ? await findLeanProjectRoot(uri) : new UntitledUri();
+        let client = this.getClientForFolder(folderUri);
+        if (client) {
+            this.activeClient = client;
+            return [true, client];
+        }
+        const key = folderUri.toString();
+        if (this.pending.has(key)) {
+            return [false, undefined];
+        }
+        this.pending.set(key, true);
+        const preconditionCheckResult = await this.checkLean4ProjectPreconditions(this.outputChannel, folderUri);
+        if (preconditionCheckResult === 'Fatal') {
+            this.pending.delete(key);
+            return [false, undefined];
+        }
+        logger.log('[ClientProvider] Creating LeanClient for ' + folderUri.toString());
+        const elanDefaultToolchain = await this.installer.getElanDefaultToolchain(folderUri);
+        client = new LeanClient(folderUri, this.outputChannel, elanDefaultToolchain, this.setupClient, this.isOpenLeanDocument);
+        this.subscriptions.push(client);
+        this.clients.set(key, client);
+        client.serverFailed(err => {
+            this.clients.delete(key);
+            client.dispose();
+            displayError(err);
+        });
+        client.stopped(reason => {
+            this.clientStoppedEmitter.fire([client, client === this.activeClient, reason]);
+        });
+        // aggregate progress changed events.
+        client.progressChanged(arg => {
+            this.progressChangedEmitter.fire(arg);
+        });
+        this.pending.delete(key);
+        this.clientAddedEmitter.fire(client);
+        await client.start();
+        // tell the InfoView about this activated client.
+        this.activeClient = client;
+        return [false, client];
+    }
+    dispose() {
+        for (const s of this.subscriptions) {
+            s.dispose();
+        }
+    }
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/converters.d.ts

@@ -0,0 +1,16 @@
+/**
+ * For LSP communication, we need a way to translate between LSP types and corresponding VSCode types.
+ * By default this translation is provided as a bunch of methods on a `LanguageClient`, but this is
+ * awkward to use in multi-client workspaces wherein we need to look up specific clients. In fact the
+ * conversions are *not* stateful, so having them depend on the client is unnecessary. Instead, we
+ * provide global converters here.
+ *
+ * Some of the conversions are patched to support extended Lean-specific structures.
+ *
+ * @module
+ */
+import { Code2ProtocolConverter, DidOpenTextDocumentParams, Protocol2CodeConverter } from 'vscode-languageclient';
+export declare function setDependencyBuildMode(params: DidOpenTextDocumentParams, dependencyBuildMode: 'once' | 'never'): DidOpenTextDocumentParams;
+export declare const p2cConverter: Protocol2CodeConverter;
+export declare const c2pConverter: Code2ProtocolConverter;
+export declare function patchConverters(p2cConverter: Protocol2CodeConverter, c2pConverter: Code2ProtocolConverter): void;