lean4monaco 1.0.45 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/utils/batch.d.ts

@@ -17,15 +17,23 @@ export interface ExecutionResult {
     stderr: string;
     combined: string;
 }
-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 {
+export declare function formatCommandExecutionOutput(workingDirectory: string | undefined, executablePath: string, args: string[]): string;
+export declare function batchExecuteWithProc(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined, envExtensions?: {
+    [key: string]: string;
+} | undefined): [ChildProcessWithoutNullStreams | 'CannotLaunch', Promise<ExecutionResult>];
+export declare function batchExecute(executablePath: string, args: string[], workingDirectory?: string | undefined, channel?: ExecutionChannel | undefined, envExtensions?: {
+    [key: string]: string;
+} | undefined): Promise<ExecutionResult>;
+export interface ProgressExecutionOptions {
     cwd?: string | undefined;
     channel?: OutputChannel | undefined;
     translator?: ((line: string) => string | undefined) | undefined;
+    envExtensions?: {
+        [key: string]: string;
+    } | undefined;
     allowCancellation?: boolean;
 }
-export declare function batchExecuteWithProgress(executablePath: string, args: string[], title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;
+export declare function batchExecuteWithProgress(executablePath: string, args: string[], context: string | undefined, title: string, options?: ProgressExecutionOptions): Promise<ExecutionResult>;
 type ExecutionHandler = () => Promise<ExecutionResult>;
 export interface BatchExecution {
     execute: ExecutionHandler;

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

@@ -1,7 +1,5 @@
-import { spawn } from 'child_process';
 import { ProgressLocation, window } from 'vscode';
-import { logger } from './logger';
-import { displayErrorWithOutput } from './notifs';
+import { displayNotificationWithOutput } from './notifs';
 export var ExecutionExitCode;
 (function (ExecutionExitCode) {
     ExecutionExitCode[ExecutionExitCode["Success"] = 0] = "Success";
@@ -17,105 +15,120 @@ function createCannotLaunchExecutionResult(message) {
         combined: message,
     };
 }
-export function batchExecuteWithProc(executablePath, args, workingDirectory, channel) {
-    let stdout = '';
-    let stderr = '';
-    let combined = '';
-    let options = {};
+export function formatCommandExecutionOutput(workingDirectory, executablePath, args) {
+    const formattedCwd = workingDirectory ? `${workingDirectory}` : '';
+    const formattedArgs = args.map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
+    return `${formattedCwd}> ${executablePath} ${formattedArgs}`;
+}
+export function batchExecuteWithProc(executablePath, args, workingDirectory, channel, envExtensions) {
+    return ["CannotLaunch", new Promise(() => { })];
+    /*
+    let stdout: string = ''
+    let stderr: string = ''
+    let combined: string = ''
+    let options = {}
     if (workingDirectory !== undefined) {
-        options = { cwd: workingDirectory };
+        options = { cwd: workingDirectory }
+    }
+    if (envExtensions !== undefined) {
+        const env = Object.assign({}, process.env)
+        for (const [key, value] of Object.entries(envExtensions)) {
+            env[key] = value
+        }
+        options = { ...options, env }
     }
     if (channel?.combined) {
-        const formattedCwd = workingDirectory ? `${workingDirectory}` : '';
-        const formattedArgs = args.map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ');
-        channel.combined.appendLine(`${formattedCwd}> ${executablePath} ${formattedArgs}`);
+        channel.combined.appendLine(formatCommandExecutionOutput(workingDirectory, executablePath, args))
     }
-    let proc;
+
+    let proc: ChildProcessWithoutNullStreams
     try {
-        proc = spawn(executablePath, args, options);
-    }
-    catch (e) {
-        return ['CannotLaunch', new Promise(resolve => resolve(createCannotLaunchExecutionResult('')))];
+        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(),
-        });
+
+    const execPromise: Promise<ExecutionResult> = new Promise(resolve => {
+        const conclude = (r: ExecutionResult) =>
+            resolve({
+                exitCode: r.exitCode,
+                stdout: r.stdout.trim(),
+                stderr: r.stderr.trim(),
+                combined: r.combined.trim(),
+            })
+
         proc.on('error', err => {
-            conclude(createCannotLaunchExecutionResult(err.message));
-        });
+            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';
-        });
+            const s: string = 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';
-        });
+            const s: string = 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}`);
+            logger.log(`child process exited with code ${code}`)
             if (signal === 'SIGTERM') {
                 if (channel?.combined) {
-                    channel.combined.appendLine('=> Operation cancelled by user.');
+                    channel.combined.appendLine('=> Operation cancelled by user.')
                 }
                 conclude({
                     exitCode: ExecutionExitCode.Cancelled,
                     stdout,
                     stderr,
                     combined,
-                });
-                return;
+                })
+                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());
+                    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;
+                })
+                return
             }
             conclude({
                 exitCode: ExecutionExitCode.Success,
                 stdout,
                 stderr,
                 combined,
-            });
-        });
-    });
-    return [proc, execPromise];
+            })
+        })
+    })
+
+    return [proc, execPromise]
+    */
 }
-export async function batchExecute(executablePath, args, workingDirectory, channel) {
-    const [_, execPromise] = batchExecuteWithProc(executablePath, args, workingDirectory, channel);
+export async function batchExecute(executablePath, args, workingDirectory, channel, envExtensions) {
+    const [_, execPromise] = batchExecuteWithProc(executablePath, args, workingDirectory, channel, envExtensions);
     return execPromise;
 }
-export async function batchExecuteWithProgress(executablePath, args, title, options = {}) {
-    const titleSuffix = options.channel ? ' [(Details)](command:lean4.troubleshooting.showOutput)' : '';
+export async function batchExecuteWithProgress(executablePath, args, context, title, options = {}) {
+    const titlePrefix = context ? `[${context}] ` : '';
+    const titleSuffix = options.channel ? ' [(Click for details)](command:lean4.troubleshooting.showOutput)' : '';
     const progressOptions = {
         location: ProgressLocation.Notification,
-        title: title + titleSuffix,
+        title: titlePrefix + title + titleSuffix,
         cancellable: options.allowCancellation === true,
     };
-    let inc = 0;
-    let lastReportedMessage;
     let progress;
     const progressChannel = {
         name: 'ProgressChannel',
@@ -129,14 +142,8 @@ export async function batchExecuteWithProgress(executablePath, args, title, opti
             }
             if (options.channel) {
                 options.channel.appendLine(value.trimEnd());
+                progress?.report({ message: value });
             }
-            if (inc < 90) {
-                inc += 2;
-            }
-            if (progress !== undefined) {
-                progress.report({ increment: inc, message: value });
-            }
-            lastReportedMessage = value;
         },
         appendLine(value) {
             this.append(value + '\n');
@@ -160,7 +167,7 @@ export async function batchExecuteWithProgress(executablePath, args, title, opti
     const expensiveExecutionTimeoutPromise = new Promise((resolve, _) => setTimeout(() => resolve(undefined), 250));
     const [proc, executionPromise] = batchExecuteWithProc(executablePath, args, options.cwd, {
         combined: progressChannel,
-    });
+    }, options.envExtensions);
     if (proc === 'CannotLaunch') {
         return executionPromise; // resolves to a 'CannotLaunch' ExecutionResult
     }
@@ -172,7 +179,6 @@ export async function batchExecuteWithProgress(executablePath, args, title, opti
     const result = await window.withProgress(progressOptions, (p, token) => {
         progress = p;
         token.onCancellationRequested(() => proc.kill());
-        progress.report({ message: lastReportedMessage, increment: inc });
         return executionPromise;
     });
     return result;
@@ -193,7 +199,7 @@ export function displayResultError(result, message) {
         throw Error();
     }
     const errorMessage = formatErrorMessage(result, message);
-    displayErrorWithOutput(errorMessage);
+    displayNotificationWithOutput('Error', errorMessage);
 }
 function formatErrorMessage(error, message) {
     if (error.combined === '') {

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

@@ -1,12 +1,11 @@
 import { LeanFileProgressProcessingInfo, ServerStoppedReason } from '@leanprover/infoview-api';
-import { Disposable, OutputChannel, TextDocument } from 'vscode';
-import { BaseLanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
-import { PreconditionCheckResult } from '../diagnostics/setupNotifs';
+import { Disposable, OutputChannel } from 'vscode';
 import { LeanClient } from '../leanclient';
+import { LeanPublishDiagnosticsParams } from './converters';
 import { ExtUri } from './exturi';
 import { LeanInstaller } from './leanInstaller';
+import { BaseLanguageClient, LanguageClientOptions } from 'vscode-languageclient/node';
 export declare class LeanClientProvider implements Disposable {
-    private checkLean4ProjectPreconditions;
     private setupClient;
     private subscriptions;
     private outputChannel;
@@ -18,20 +17,21 @@ export declare class LeanClientProvider implements Disposable {
     private activeClient;
     private progressChangedEmitter;
     progressChanged: import("vscode").Event<[string, LeanFileProgressProcessingInfo[]]>;
+    private diagnosticsChangedEmitter;
+    diagnosticsChanged: import("vscode").Event<LeanPublishDiagnosticsParams>;
     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, checkLean4ProjectPreconditions: (channel: OutputChannel, folderUri: ExtUri) => Promise<PreconditionCheckResult>, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>);
+    constructor(installer: LeanInstaller, outputChannel: OutputChannel, setupClient: (clientOptions: LanguageClientOptions) => Promise<BaseLanguageClient>);
     getActiveClient(): LeanClient | undefined;
     private onInstallChanged;
-    private restartFile;
-    private stopActiveClient;
+    restartFile(uri: ExtUri): void;
+    restartActiveFile(): void;
+    private stopClient;
     private restartActiveClient;
-    clientIsStarted(): void;
-    didOpenEditor(document: TextDocument): Promise<void>;
     findClient(path: ExtUri): LeanClient | undefined;
     getClients(): LeanClient[];
     getClientForFolder(folder: ExtUri): LeanClient | undefined;

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

@@ -1,12 +1,27 @@
-import { EventEmitter, commands, window, workspace } from 'vscode';
+import { EventEmitter, commands } from 'vscode';
+import { SetupDiagnostics, checkAll } from '../diagnostics/setupDiagnostics';
 import { LeanClient } from '../leanclient';
-import { UntitledUri, getWorkspaceFolderUri, toExtUri } from './exturi';
+import { lean } from './leanEditorProvider';
 import { logger } from './logger';
-import { displayError } from './notifs';
-import { findLeanProjectRoot } from './projectInfo';
+import { displayNotification } from './notifs';
+import { findLeanProjectRootInfo, willUseLakeServer } from './projectInfo';
+async function checkLean4ProjectPreconditions(channel, context, existingFolderUris, folderUri, fileUri, stopOtherServer) {
+    const options = {
+        errorMode: { mode: 'NonModal' },
+        warningMode: { modal: false, proceedByDefault: true },
+    };
+    const d = new SetupDiagnostics(options);
+    return await checkAll(() => d.checkIsValidProjectFolder(channel, folderUri), () => d.checkIsLeanVersionUpToDate(channel, context, folderUri, { toolchainUpdateMode: 'PromptAboutUpdate' }), async () => {
+        if (!(await willUseLakeServer(folderUri))) {
+            return 'Fulfilled';
+        }
+        return await d.checkIsLakeInstalledCorrectly(channel, context, folderUri, {
+            toolchainUpdateMode: 'PromptAboutUpdate',
+        });
+    }, () => d.checkIsNestedProjectFolder(existingFolderUris, folderUri, fileUri, stopOtherServer));
+}
 // This class ensures we have one LeanClient per folder.
 export class LeanClientProvider {
-    checkLean4ProjectPreconditions;
     setupClient;
     subscriptions = [];
     outputChannel;
@@ -18,50 +33,35 @@ export class LeanClientProvider {
     activeClient = undefined;
     progressChangedEmitter = new EventEmitter();
     progressChanged = this.progressChangedEmitter.event;
+    diagnosticsChangedEmitter = new EventEmitter();
+    diagnosticsChanged = this.diagnosticsChangedEmitter.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, checkLean4ProjectPreconditions, setupClient) {
-        this.checkLean4ProjectPreconditions = checkLean4ProjectPreconditions;
+    constructor(installer, outputChannel, setupClient) {
         this.setupClient = setupClient;
         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) {
+        lean.visibleLeanEditors.forEach(e => this.ensureClient(e.documentExtUri));
+        this.subscriptions.push(lean.onDidChangeActiveLeanEditor(async (e) => {
+            if (e === undefined) {
                 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);
-            });
+            await this.ensureClient(e.documentExtUri);
         }));
+        this.subscriptions.push(commands.registerCommand('lean4.restartFile', () => this.restartActiveFile()), commands.registerCommand('lean4.refreshFileDependencies', () => this.restartActiveFile()), commands.registerCommand('lean4.restartServer', () => this.restartActiveClient()), commands.registerCommand('lean4.stopServer', () => this.stopClient(undefined)));
+        this.subscriptions.push(lean.onDidOpenLeanDocument(document => this.ensureClient(document.extUri)));
     }
     getActiveClient() {
+        // TODO: Most callers of this function probably don't need an active client, just the folder URI.
         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.
@@ -74,18 +74,9 @@ export class LeanClientProvider {
                 break;
             }
             try {
-                const projectUri = await findLeanProjectRoot(uri);
-                if (projectUri === 'FileNotFound') {
-                    continue;
-                }
-                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');
-                    }
+                const [cached, client] = await this.ensureClient(uri);
+                if (cached && client) {
+                    await client.restart();
                 }
             }
             catch (e) {
@@ -94,38 +85,69 @@ export class LeanClientProvider {
         }
         this.processingInstallChanged = false;
     }
-    restartFile() {
-        if (!this.activeClient || !this.activeClient.isRunning()) {
-            displayError('No active client.');
+    restartFile(uri) {
+        const fileName = uri.scheme === 'file' ? uri.baseName() : 'untitled file';
+        const client = this.findClient(uri);
+        if (!client || !client.isRunning()) {
+            displayNotification('Error', `No active client for '${fileName}'.`);
             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.');
+        const doc = lean.getLeanDocumentByUri(uri);
+        if (doc === undefined) {
+            displayNotification('Error', `'${fileName}' was closed in the meantime.`);
             return;
         }
-        void this.activeClient.restartFile(window.activeTextEditor.document);
+        void client.restartFile(doc);
     }
-    stopActiveClient() {
-        if (this.activeClient && this.activeClient.isStarted()) {
-            void this.activeClient?.stop();
+    restartActiveFile() {
+        const doc = lean.lastActiveLeanDocument;
+        if (doc === undefined) {
+            displayNotification('Error', 'No active Lean editor tab. Make sure to focus the Lean editor tab for which you want to issue a restart.');
+            return;
         }
+        this.restartFile(doc.extUri);
     }
-    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;
+    async stopClient(folderUri) {
+        let clientToStop;
+        if (folderUri === undefined) {
+            if (this.activeClient === undefined) {
+                displayNotification('Error', 'Cannot stop language server: No active client.');
+                return;
+            }
+            clientToStop = this.activeClient;
         }
-        const uri = toExtUri(document.uri);
-        if (uri === undefined) {
+        else {
+            const foundClient = this.getClientForFolder(folderUri);
+            if (foundClient === undefined) {
+                displayNotification('Error', `Cannot stop language server: No client for project at '${folderUri.toString()}'.`);
+                return;
+            }
+            clientToStop = foundClient;
+        }
+        if (clientToStop.isStarted()) {
+            await clientToStop.stop();
+        }
+        const key = clientToStop.folderUri.toString();
+        this.clients.delete(key);
+        this.pending.delete(key);
+        if (clientToStop === this.activeClient) {
+            this.activeClient = undefined;
+        }
+    }
+    async restartActiveClient() {
+        if (this.activeClient === undefined) {
+            const activeUri = lean.lastActiveLeanDocument?.extUri;
+            if (activeUri === undefined) {
+                displayNotification('Error', 'Cannot restart server: No focused Lean tab. Please focus the Lean tab for which you want to restart the server.');
+                return;
+            }
+            const [cached, client] = await this.ensureClient(activeUri);
+            if (cached) {
+                await client?.restart();
+            }
             return;
         }
-        await this.ensureClient(uri);
+        await this.activeClient?.restart();
     }
     // Find the client for a given document.
     findClient(path) {
@@ -154,14 +176,16 @@ export class LeanClientProvider {
     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();
-        if (folderUri === 'FileNotFound') {
+        const projectInfo = await findLeanProjectRootInfo(uri);
+        if (projectInfo.kind === 'FileNotFound') {
+            return [false, undefined];
+        }
+        if (projectInfo.kind === 'LakefileWithoutToolchain') {
+            displayNotification('Error', `Project at ${projectInfo.projectRootUri} has a Lakefile, but lacks a 'lean-toolchain' file. Please create one with the Lean version that you would like the project to use.`);
             return [false, undefined];
         }
+        const folderUri = projectInfo.projectRootUri;
         let client = this.getClientForFolder(folderUri);
         if (client) {
             this.activeClient = client;
@@ -172,20 +196,36 @@ export class LeanClientProvider {
             return [false, undefined];
         }
         this.pending.set(key, true);
-        const preconditionCheckResult = await this.checkLean4ProjectPreconditions(this.outputChannel, folderUri);
+        // lean4monaco: The precondition checks require a file system or executables, which we don't have in the browser.
+        /*
+        const preconditionCheckResult = await checkLean4ProjectPreconditions(
+            this.outputChannel,
+            'Client Startup',
+            this.getClients().map(client => client.folderUri),
+            folderUri,
+            uri,
+            async (folderUriToStop: FileUri) => {
+                await this.stopClient(folderUriToStop)
+                await this.ensureClient(uri)
+            },
+        )
         if (preconditionCheckResult === 'Fatal') {
-            this.pending.delete(key);
-            return [false, undefined];
+            this.pending.delete(key)
+            this.activeClient = undefined
+            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);
+        client = new LeanClient(folderUri, this.outputChannel, this.setupClient);
         this.subscriptions.push(client);
         this.clients.set(key, client);
         client.serverFailed(err => {
+            if (this.activeClient === client) {
+                this.activeClient = undefined;
+            }
             this.clients.delete(key);
             client.dispose();
-            displayError(err);
+            displayNotification('Error', err);
         });
         client.stopped(reason => {
             this.clientStoppedEmitter.fire([client, client === this.activeClient, reason]);
@@ -194,10 +234,14 @@ export class LeanClientProvider {
         client.progressChanged(arg => {
             this.progressChangedEmitter.fire(arg);
         });
-        this.pending.delete(key);
+        client.diagnostics(p => {
+            this.diagnosticsChangedEmitter.fire(p);
+        });
+        // Fired before starting the client because the InfoView uses this to register
+        // events on `client` that fire during `start`.
         this.clientAddedEmitter.fire(client);
         await client.start();
-        // tell the InfoView about this activated client.
+        this.pending.delete(key);
         this.activeClient = client;
         return [false, client];
     }

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

@@ -10,6 +10,21 @@
  * @module
  */
 import { Code2ProtocolConverter, DidOpenTextDocumentParams, Protocol2CodeConverter } from 'vscode-languageclient';
+import * as ls from 'vscode-languageserver-protocol';
+export declare enum LeanTag {
+    UnsolvedGoals = 1,
+    GoalsAccomplished = 2
+}
+export interface LeanDiagnostic extends ls.Diagnostic {
+    fullRange?: ls.Range;
+    isSilent?: boolean;
+    leanTags?: LeanTag[];
+}
+export interface LeanPublishDiagnosticsParams {
+    uri: ls.DocumentUri;
+    version?: ls.integer;
+    diagnostics: LeanDiagnostic[];
+}
 export declare function setDependencyBuildMode(params: DidOpenTextDocumentParams, dependencyBuildMode: 'once' | 'never'): DidOpenTextDocumentParams;
 export declare const p2cConverter: Protocol2CodeConverter;
 export declare const c2pConverter: Code2ProtocolConverter;

package/dist/vscode-lean4/vscode-lean4/src/utils/converters.js

@@ -15,6 +15,11 @@ import { createConverter as createP2CConverter } from 'vscode-languageclient/lib
 import * as async from 'vscode-languageclient/lib/common/utils/async';
 import * as ls from 'vscode-languageserver-protocol';
 import { automaticallyBuildDependencies } from '../config';
+export var LeanTag;
+(function (LeanTag) {
+    LeanTag[LeanTag["UnsolvedGoals"] = 1] = "UnsolvedGoals";
+    LeanTag[LeanTag["GoalsAccomplished"] = 2] = "GoalsAccomplished";
+})(LeanTag || (LeanTag = {}));
 var SnippetTextEdit;
 (function (SnippetTextEdit) {
     function is(value) {
@@ -50,6 +55,8 @@ export function patchConverters(p2cConverter, c2pConverter) {
         }
         const diag = oldP2cAsDiagnostic.apply(this, [protDiag]);
         diag.fullRange = p2cConverter.asRange(protDiag.fullRange);
+        diag.leanTags = protDiag.leanTags;
+        diag.isSilent = protDiag.isSilent;
         return diag;
     };
     // The original definition refers to `asDiagnostic` as a local function
@@ -61,6 +68,8 @@ export function patchConverters(p2cConverter, c2pConverter) {
     c2pConverter.asDiagnostic = function (diag) {
         const protDiag = oldC2pAsDiagnostic.apply(this, [diag]);
         protDiag.fullRange = c2pConverter.asRange(diag.fullRange);
+        protDiag.leanTags = diag.leanTags;
+        protDiag.isSilent = diag.isSilent;
         return protDiag;
     };
     c2pConverter.asDiagnostics = async (diags, token) => async.map(diags, d => c2pConverter.asDiagnostic(d), token);