lean4monaco 1.0.46 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/leanclient.js

@@ -1,16 +1,22 @@
-import { Disposable, DocumentHighlightKind, EventEmitter, ProgressLocation, Range, window, workspace, } from 'vscode';
-import { DiagnosticSeverity, RevealOutputChannelOn, State, } from 'vscode-languageclient/node';
-import { getElaborationDelay, getFallBackToStringOccurrenceHighlighting, shouldAutofocusOutput } from './config';
+import { Disposable, DocumentHighlightKind, EventEmitter, ProgressLocation, Range, window, } from 'vscode';
+import { DiagnosticSeverity, LanguageClient, RevealOutputChannelOn, State, } from 'vscode-languageclient/node';
+import { getElaborationDelay, getFallBackToStringOccurrenceHighlighting, serverArgs, serverLoggingEnabled, serverLoggingPath, shouldAutofocusOutput, } from './config';
 import { logger } from './utils/logger';
 // @ts-ignore
 import { SemVer } from 'semver';
-import { c2pConverter, p2cConverter, patchConverters, setDependencyBuildMode } from './utils/converters';
+import { formatCommandExecutionOutput } from './utils/batch';
+import { c2pConverter, p2cConverter, patchConverters, setDependencyBuildMode, } from './utils/converters';
+import { elanInstalledToolchains } from './utils/elan';
 import { parseExtUri, toExtUri } from './utils/exturi';
-import { displayError, displayErrorWithOptionalInput, displayErrorWithOutput, displayInformationWithOptionalInput, } from './utils/notifs';
-import path from 'path';
+import { lean } from './utils/leanEditorProvider';
+import { displayNotification, displayNotificationWithOptionalInput, displayNotificationWithOutput, } from './utils/notifs';
+import { willUseLakeServer } from './utils/projectInfo';
+const leanClientCapabilities = {
+    silentDiagnosticSupport: true,
+};
 const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 export class LeanClient {
-    setupClient;
+    setupLanguageClient;
     running;
     client;
     outputChannel;
@@ -18,7 +24,6 @@ export class LeanClient {
     subscriptions = [];
     noPrompt = false;
     showingRestartMessage = false;
-    elanDefaultToolchain;
     isRestarting = false;
     staleDepNotifier;
     openServerDocuments = new Set();
@@ -47,16 +52,11 @@ export class LeanClient {
     restartedWorker = this.restartedWorkerEmitter.event;
     serverFailedEmitter = new EventEmitter();
     serverFailed = this.serverFailedEmitter.event;
-    constructor(folderUri, outputChannel, elanDefaultToolchain, setupClient) {
-        this.setupClient = setupClient;
-        this.outputChannel = outputChannel; // can be null when opening adhoc files.
+    constructor(folderUri, outputChannel, setupLanguageClient) {
+        this.setupLanguageClient = setupLanguageClient;
+        this.outputChannel = outputChannel;
         this.folderUri = folderUri;
-        this.elanDefaultToolchain = elanDefaultToolchain;
-        this.subscriptions.push(new Disposable(() => {
-            if (this.staleDepNotifier) {
-                this.staleDepNotifier.dispose();
-            }
-        }));
+        this.subscriptions.push(new Disposable(() => this.staleDepNotifier?.dispose()));
     }
     dispose() {
         this.subscriptions.forEach(s => s.dispose());
@@ -81,25 +81,49 @@ export class LeanClient {
             restartItem = 'Restart Lean Server on this file';
             messageTitle = 'The Lean Server has stopped processing this file.';
         }
-        displayErrorWithOptionalInput(messageTitle, restartItem, () => {
-            if (restartFile && uri !== undefined) {
-                const document = workspace.textDocuments.find(doc => uri.equalsUri(doc.uri));
-                if (document) {
-                    void this.restartFile(document);
-                }
-            }
-            else {
-                void this.start();
-            }
-        }, finalizer);
+        displayNotificationWithOptionalInput('Error', messageTitle, [
+            {
+                input: restartItem,
+                action: () => {
+                    if (restartFile && uri !== undefined) {
+                        const document = lean.getLeanDocumentByUri(uri);
+                        if (document !== undefined) {
+                            void this.restartFile(document);
+                        }
+                    }
+                    else {
+                        void this.start();
+                    }
+                },
+            },
+        ], finalizer);
     }
     async restart() {
         if (this.isRestarting) {
-            displayError('Client is already being started.');
+            displayNotification('Error', 'Client is already being started.');
             return;
         }
         this.isRestarting = true;
         try {
+            let defaultToolchain;
+            if (this.folderUri.scheme === 'untitled') {
+                const installedToolchainsResult = await elanInstalledToolchains();
+                switch (installedToolchainsResult.kind) {
+                    case 'Success':
+                        if (installedToolchainsResult.defaultToolchain === undefined) {
+                            this.serverFailedEmitter.fire('No default Lean version set - cannot launch client for untitled file.');
+                            return;
+                        }
+                        defaultToolchain = installedToolchainsResult.defaultToolchain;
+                        break;
+                    case 'ElanNotFound':
+                        defaultToolchain = undefined;
+                        break;
+                    case 'ExecutionError':
+                        this.serverFailedEmitter.fire(`Cannot determine Lean version information for launching a client for an untitled file: ${installedToolchainsResult.message}`);
+                        return;
+                }
+            }
             logger.log('[LeanClient] Restarting Lean Server');
             if (this.isStarted()) {
                 await this.stop();
@@ -107,21 +131,54 @@ export class LeanClient {
             this.restartingEmitter.fire(undefined);
             const progressOptions = {
                 location: ProgressLocation.Notification,
-                title: 'Starting Lean language client',
+                title: '[Server Startup] Starting Lean language server and cloning missing packages [(Click for details)](command:lean4.troubleshooting.showOutput)',
                 cancellable: false,
             };
-            await window.withProgress(progressOptions, async (progress) => await this.startClient(progress));
+            await window.withProgress(progressOptions, async (progress) => await this.startClient(progress, defaultToolchain));
         }
         finally {
             this.isRestarting = false;
         }
     }
-    async startClient(progress) {
+    async determineToolchainOverride(defaultToolchain) {
+        /*
+        const cwdUri = this.folderUri.scheme === 'file' ? this.folderUri : undefined
+        const toolchainDecision = await leanRunner.decideToolchain({
+            channel: this.outputChannel,
+            context: 'Server Startup',
+            cwdUri,
+            toolchainUpdateMode: 'PromptAboutUpdate',
+        })
+
+        if (toolchainDecision.kind === 'Error') {
+            return toolchainDecision
+        }
+
+        if (toolchainDecision.kind === 'RunWithSpecificToolchain') {
+            return { kind: 'Override', toolchain: toolchainDecision.toolchain }
+        }
+
+        toolchainDecision.kind satisfies 'RunWithActiveToolchain'
+
+        if (this.folderUri.scheme === 'untitled' && defaultToolchain !== undefined) {
+            // Fixes issue #227, for adhoc files it would pick up the cwd from the open folder
+            // which is not what we want.  For adhoc files we want the (default) toolchain instead.
+            return { kind: 'Override', toolchain: defaultToolchain }
+        }
+        */
+        return { kind: 'NoOverride' };
+    }
+    async startClient(progress, defaultToolchain) {
         // Should only be called from `restart`
         const startTime = Date.now();
-        progress.report({ increment: 0 });
-        this.client = await this.setupClient(this.obtainClientOptions(), this.folderUri, this.elanDefaultToolchain);
-        patchConverters(this.client.protocol2CodeConverter, this.client.code2ProtocolConverter);
+        progress.report({});
+        const toolchainOverrideResult = await this.determineToolchainOverride(defaultToolchain);
+        if (toolchainOverrideResult.kind === 'Error') {
+            this.serverFailedEmitter.fire(`Error while starting client: ${toolchainOverrideResult.message}`);
+            return;
+        }
+        const toolchainOverride = toolchainOverrideResult.kind === 'Override' ? toolchainOverrideResult.toolchain : undefined;
+        this.client = await this.setupLanguageClient(this.obtainClientOptions());
         let insideRestart = true;
         try {
             this.client.onDidChangeState(async (s) => {
@@ -148,7 +205,6 @@ export class LeanClient {
                     }
                 }
             });
-            progress.report({ increment: 80 });
             await this.client.start();
             const version = this.client.initializeResult?.serverInfo?.version;
             if (version && new SemVer(version).compare('0.2.0') < 0) {
@@ -166,7 +222,6 @@ export class LeanClient {
             this.outputChannel.appendLine(msg);
             this.serverFailedEmitter.fire(msg);
             insideRestart = false;
-            return;
         }
         // HACK(WN): Register a default notification handler to fire on custom notifications.
         // A mechanism to do this is provided in vscode-jsonrpc. One can register a `StarNotificationHandler`
@@ -199,7 +254,7 @@ export class LeanClient {
                 const finalizer = () => {
                     stderrMsgBoxVisible = false;
                 };
-                displayErrorWithOutput(`Lean server printed an error:\n${chunk.toString()}`, finalizer);
+                displayNotificationWithOutput('Error', `Lean server printed an error:\n${chunk.toString()}`, [], finalizer);
             }
         });
         this.restartedEmitter.fire(undefined);
@@ -210,7 +265,7 @@ export class LeanClient {
         if (fileUri === undefined) {
             return;
         }
-        const fileName = fileUri.scheme === 'file' ? path.basename(fileUri.fsPath) : 'untitled';
+        const fileName = fileUri.scheme === 'file' ? fileUri.baseName() : 'untitled';
         const isImportsOutdatedError = params.diagnostics.some(d => d.severity === DiagnosticSeverity.Error &&
             d.message.includes('Imports are out of date and must be rebuilt') &&
             d.range.start.line === 0 &&
@@ -222,25 +277,34 @@ export class LeanClient {
         }
         const message = `Imports of '${fileName}' are out of date and must be rebuilt. Restarting the file will rebuild them.`;
         const input = 'Restart File';
-        displayInformationWithOptionalInput(message, input, () => {
-            const document = workspace.textDocuments.find(doc => fileUri.equalsUri(doc.uri));
-            if (!document || document.isClosed) {
-                displayError(`'${fileName}' was closed in the meantime. Imports will not be rebuilt.`);
-                return;
-            }
-            void this.restartFile(document);
-        });
+        displayNotificationWithOptionalInput('Information', message, [
+            {
+                input,
+                action: () => {
+                    const document = lean.getLeanDocumentByUri(fileUri);
+                    if (document === undefined) {
+                        displayNotification('Error', `'${fileName}' was closed in the meantime. Imports will not be rebuilt.`);
+                        return;
+                    }
+                    void this.restartFile(document);
+                },
+            },
+        ]);
     }
     async withStoppedClient(action) {
         if (this.isRestarting) {
             return 'IsRestarting';
         }
         this.isRestarting = true; // Ensure that client cannot be restarted in the mean-time
-        if (this.isStarted()) {
-            await this.stop();
+        try {
+            if (this.isStarted()) {
+                await this.stop();
+            }
+            await action();
+        }
+        finally {
+            this.isRestarting = false;
         }
-        await action();
-        this.isRestarting = false;
         await this.restart();
         return 'Success';
     }
@@ -286,27 +350,31 @@ export class LeanClient {
         this.openServerDocuments = new Set();
         this.running = false;
     }
-    async restartFile(doc) {
-        if (this.client === undefined || !this.running)
-            return; // there was a problem starting lean server.
-        const docUri = toExtUri(doc.uri);
-        if (docUri === undefined) {
+    async restartFile(leanDoc) {
+        const extUri = leanDoc.extUri;
+        const formattedFileName = extUri.scheme === 'file' ? extUri.baseName() : extUri.toString();
+        const formattedProjectName = this.folderUri.scheme === 'file' ? this.folderUri.fsPath : this.folderUri.toString();
+        if (this.client === undefined || !this.running) {
+            displayNotification('Error', `Cannot restart '${formattedFileName}': The language server for the project at '${formattedProjectName}' is stopped.`);
             return;
         }
-        if (!this.isInFolderManagedByThisClient(docUri)) {
+        if (!this.isInFolderManagedByThisClient(extUri)) {
+            displayNotification('Error', `Cannot restart '${formattedFileName}': The project at '${formattedProjectName}' does not contain the file.`);
             return;
         }
-        const uri = docUri.toString();
+        const uri = extUri.toString();
         if (!this.openServerDocuments.delete(uri)) {
+            displayNotification('Error', `Cannot restart '${formattedFileName}': The file has never been opened in the language server for the project at '${formattedProjectName}'.`);
             return;
         }
         logger.log(`[LeanClient] Restarting File: ${uri}`);
-        await this.client.sendNotification('textDocument/didClose', this.client.code2ProtocolConverter.asCloseTextDocumentParams(doc));
+        await this.client.sendNotification('textDocument/didClose', this.client.code2ProtocolConverter.asCloseTextDocumentParams(leanDoc.doc));
         if (this.openServerDocuments.has(uri)) {
+            displayNotification('Error', `Cannot restart '${formattedFileName}': The file has already been opened in the language server for the project at '${formattedProjectName}' since initiating the restart.`);
             return;
         }
         this.openServerDocuments.add(uri);
-        await this.client.sendNotification('textDocument/didOpen', setDependencyBuildMode(this.client.code2ProtocolConverter.asOpenTextDocumentParams(doc), 'once'));
+        await this.client.sendNotification('textDocument/didOpen', setDependencyBuildMode(this.client.code2ProtocolConverter.asOpenTextDocumentParams(leanDoc.doc), 'once'));
         this.restartedWorkerEmitter.fire(uri);
     }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
@@ -314,7 +382,7 @@ export class LeanClient {
         return this.running && this.client
             ? this.client.sendRequest(method, params)
             : new Promise((_, reject) => {
-                reject('Client is not running');
+                reject('No connection to Lean');
             });
     }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
@@ -327,6 +395,40 @@ export class LeanClient {
     get initializeResult() {
         return this.running ? this.client?.initializeResult : undefined;
     }
+    async determineServerOptions(toolchainOverride) {
+        const env = Object.assign({}, process.env);
+        if (serverLoggingEnabled()) {
+            env.LEAN_SERVER_LOG_DIR = serverLoggingPath();
+        }
+        const [serverExecutable, options] = await this.determineExecutable();
+        if (toolchainOverride) {
+            options.unshift('+' + toolchainOverride);
+        }
+        const cwd = this.folderUri.scheme === 'file' ? this.folderUri.fsPath : undefined;
+        if (cwd) {
+            // Add folder name to command-line so that it shows up in `ps aux`.
+            options.push(cwd);
+        }
+        else {
+            options.push('untitled');
+        }
+        return {
+            command: serverExecutable,
+            args: options.concat(serverArgs()),
+            options: {
+                cwd,
+                env,
+            },
+        };
+    }
+    async determineExecutable() {
+        if (await willUseLakeServer(this.folderUri)) {
+            return ['lake', ['serve', '--']];
+        }
+        else {
+            return ['lean', ['--server']];
+        }
+    }
     obtainClientOptions() {
         const documentSelector = {
             language: 'lean4',
@@ -334,10 +436,11 @@ export class LeanClient {
         let workspaceFolder;
         documentSelector.scheme = this.folderUri.scheme;
         if (this.folderUri.scheme === 'file') {
-            documentSelector.pattern = `${this.folderUri.fsPath}/**/*`;
+            const escapedPath = this.folderUri.fsPath.replace(/[?*()[\]{}]/g, '[$&]');
+            documentSelector.pattern = `${escapedPath}/**/*`;
             workspaceFolder = {
                 uri: this.folderUri.asUri(),
-                name: path.basename(this.folderUri.fsPath),
+                name: this.folderUri.baseName(),
                 index: 0, // the language client library does not actually need this index
             };
         }
@@ -356,7 +459,8 @@ export class LeanClient {
             },
             middleware: {
                 handleDiagnostics: (uri, diagnostics, next) => {
-                    next(uri, diagnostics);
+                    const diagnosticsInVsCode = diagnostics.filter(d => !('isSilent' in d && d.isSilent));
+                    next(uri, diagnosticsInVsCode);
                     const uri_ = c2pConverter.asUri(uri);
                     const diagnostics_ = [];
                     for (const d of diagnostics) {
@@ -436,4 +540,23 @@ export class LeanClient {
             },
         };
     }
+    async setupClient(toolchainOverride) {
+        const serverOptions = await this.determineServerOptions(toolchainOverride);
+        const clientOptions = this.obtainClientOptions();
+        this.outputChannel.appendLine(formatCommandExecutionOutput(serverOptions.options?.cwd, serverOptions.command, serverOptions.args ?? []));
+        const client = new LanguageClient('lean4', 'Lean 4', serverOptions, clientOptions);
+        const leanCapabilityFeature = {
+            initialize(_1, _2) { },
+            getState() {
+                return { kind: 'static' };
+            },
+            fillClientCapabilities(capabilities) {
+                capabilities.lean = leanClientCapabilities;
+            },
+            clear() { },
+        };
+        client.registerFeature(leanCapabilityFeature);
+        patchConverters(client.protocol2CodeConverter, client.code2ProtocolConverter);
+        return client;
+    }
 }

package/dist/vscode-lean4/vscode-lean4/src/taskgutter.d.ts

@@ -1,11 +1,43 @@
 import { Disposable, ExtensionContext } from 'vscode';
 import { LeanClientProvider } from './utils/clientProvider';
+import { LeanDiagnostic } from './utils/converters';
+type DiagStart = 'None' | {
+    kind: 'Error' | 'Warning' | 'GoalsAccomplished';
+    range: 'SingleLine' | 'MultiLine';
+};
+interface DiagnosticGutterDeco {
+    line: number;
+    diagStart: DiagStart;
+    isPreviousDiagContinue: boolean;
+    isPreviousDiagEnd: boolean;
+}
+declare const diagnosticGutterDecoKinds: readonly ["error", "error-init", "error-i", "error-i-passthrough", "error-l", "error-l-passthrough", "error-t", "error-t-passthrough", "warning", "warning-i-passthrough", "warning-l-passthrough", "warning-t-passthrough", "goals-accomplished-checkmark", "goals-accomplished-checkmark-i-passthrough", "goals-accomplished-checkmark-l-passthrough", "goals-accomplished-checkmark-t-passthrough", "goals-accomplished-circled-checkmark", "goals-accomplished-circled-checkmark-i-passthrough", "goals-accomplished-circled-checkmark-l-passthrough", "goals-accomplished-circled-checkmark-t-passthrough", "goals-accomplished-octopus", "goals-accomplished-octopus-i-passthrough", "goals-accomplished-octopus-l-passthrough", "goals-accomplished-octopus-t-passthrough", "goals-accomplished-tada", "goals-accomplished-tada-i-passthrough", "goals-accomplished-tada-l-passthrough", "goals-accomplished-tada-t-passthrough"];
+type DiagnosticGutterDecoKind = (typeof diagnosticGutterDecoKinds)[number];
 export declare class LeanTaskGutter implements Disposable {
-    private decorations;
-    private status;
+    private context;
+    private processingDecorationType;
+    private fatalErrorDecorationType;
+    private unsolvedGoalsDecorationType;
+    private diagnosticGutterDecorationTypes;
     private gutters;
     private subscriptions;
+    private showDiagnosticGutterDecorations;
+    private goalsAccomplishedDecorationKind;
+    private showUnsolvedGoalsDecoration;
     constructor(client: LeanClientProvider, context: ExtensionContext);
-    private updateDecos;
+    private checkContext;
+    private getGutter;
+    private onDidChangeColorTheme;
+    private onDidReveal;
+    private onProgressChanged;
+    private onDiagnosticsChanged;
+    private computeDiagnosticGutterDecoStates;
+    computeDiagnosticGutterDecos(diagnostics: LeanDiagnostic[]): DiagnosticGutterDeco[];
+    isGutterDecoDiagnostic(d: LeanDiagnostic): boolean;
+    getGoalsAccomplishedDiagnosticGutterDecoKindName(): string;
+    determineSingleLineDiagnosticGutterDecoKind(d: DiagnosticGutterDeco, name: string): DiagnosticGutterDecoKind;
+    determineDiagnosticGutterDecoKind(d: DiagnosticGutterDeco): DiagnosticGutterDecoKind | undefined;
+    private computeUnsolvedGoalsDecoState;
     dispose(): void;
 }
+export {};