lean4monaco 1.0.45 → 1.1.0

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

@@ -0,0 +1,35 @@
+import { env } from 'vscode';
+import { displayModalNotification, displayNotificationWithInput } from './notifs';
+export async function displayInternalError(scope, e) {
+    let msg = `Internal error (while ${scope}): ${e}`;
+    let fullMsg = msg;
+    if (e instanceof Error && e.stack !== undefined) {
+        fullMsg += `\n\n${e.stack}`;
+    }
+    msg +=
+        "\n\nIf you are using an up-to-date version of the Lean 4 VS Code extension, please copy the full error message using the 'Copy Error to Clipboard' button and report it at https://github.com/leanprover/vscode-lean4/ or https://leanprover.zulipchat.com/.";
+    const copyToClipboardInput = 'Copy Error to Clipboard';
+    const closeInput = 'Close';
+    const choice = await displayNotificationWithInput('Error', msg, [copyToClipboardInput], closeInput);
+    if (choice === copyToClipboardInput) {
+        await env.clipboard.writeText(fullMsg);
+    }
+}
+const duplicateCommandError = (scope) => `Error (while ${scope}): Two separate Lean 4 VS Code extensions that register the same VS Code functionality are installed.
+Please uninstall or disable one of them and restart VS Code.
+
+The 'Lean 4' extension by the 'leanprover' organization is the only official Lean 4 VS Code extension.`;
+export async function displayInternalErrorsIn(scope, f) {
+    try {
+        return await f();
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg !== undefined && typeof msg === 'string' && msg.match(/command '.*' already exists/)) {
+            await displayModalNotification('Error', duplicateCommandError(scope));
+            throw e;
+        }
+        await displayInternalError(scope, e);
+        throw e;
+    }
+}

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

@@ -13,7 +13,7 @@ function overrideReason(activeOverride) {
         case 'Environment':
             return undefined;
         case 'Manual':
-            return `set by \`elan override\` in folder '${path.basename(activeOverride.directoryPath.fsPath)}'`;
+            return `set by \`elan override\` in folder '${activeOverride.directoryPath.baseName()}'`;
         case 'ToolchainFile':
             return `of Lean project '${path.dirname(activeOverride.toolchainPath.fsPath)}'`;
         case 'LeanpkgFile':

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

@@ -1,21 +1,30 @@
 import { SemVer } from 'semver';
-import { OutputChannel } from 'vscode';
-import { ExtUri, FileUri } from './exturi';
-import { NotificationSeverity } from './notifs';
+import { Disposable, OutputChannel } from 'vscode';
+import { FileUri } from './exturi';
+import { NotificationSeverity, StickyInput, StickyNotificationOptions } from './notifs';
 export declare class LeanVersion {
     version: string;
     error: string | undefined;
 }
+export type UpdateElanMode = {
+    kind: 'Outdated';
+    versions: {
+        currentVersion: SemVer;
+        recommendedVersion: SemVer;
+    };
+} | {
+    kind: 'Manual';
+    versions: {
+        currentVersion: SemVer;
+    };
+};
 export declare class LeanInstaller {
     private leanInstallerLinux;
     private leanInstallerWindows;
     private outputChannel;
     private prompting;
-    private installing;
+    private pendingOperation;
     private freshInstallDefaultToolchain;
-    private elanDefaultToolchain;
-    private workspaceSuffix;
-    private defaultSuffix;
     private promptUser;
     private installChangedEmitter;
     installChanged: import("vscode").Event<FileUri>;
@@ -26,12 +35,32 @@ export declare class LeanInstaller {
     isPromptVisible(): boolean;
     private showRestartPromptAndRestart;
     handleLakeFileChanged(packageUri: FileUri): void;
-    private removeSuffix;
-    getElanDefaultToolchain(packageUri: ExtUri): Promise<string>;
-    elanListToolChains(packageUri: ExtUri): Promise<string[]>;
-    hasElan(): Promise<boolean>;
+    private installElanPrompt;
+    displayInstallElanPromptWithItems(severity: NotificationSeverity, reason: string | undefined, otherItems?: string[], defaultItem?: string | undefined): Promise<{
+        kind: 'InstallElan';
+        success: boolean;
+    } | {
+        kind: 'OtherItem';
+        choice: string;
+    } | undefined>;
     displayInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined): Promise<boolean>;
-    displayUpdateElanPrompt(severity: NotificationSeverity, currentVersion: SemVer, recommendedVersion: SemVer): Promise<boolean>;
+    displayStickyInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined, options: StickyNotificationOptions<'Install Elan' | string>, otherItems?: StickyInput<string>[]): Disposable;
+    private updateElanPrompt;
+    private displayElanUpdateSuccessfulPrompt;
+    private updateElan;
+    displayUpdateElanPromptWithItems(severity: NotificationSeverity, mode: UpdateElanMode, otherItems?: string[], defaultItem?: string | undefined): Promise<{
+        kind: 'UpdateElan';
+        success: boolean;
+    } | {
+        kind: 'OtherItem';
+        choice: string;
+    } | undefined>;
+    displayUpdateElanPrompt(severity: NotificationSeverity, mode: UpdateElanMode): Promise<boolean>;
+    displayStickyUpdateElanPrompt(severity: NotificationSeverity, mode: UpdateElanMode, options: StickyNotificationOptions<'Update Elan' | string>, otherItems?: StickyInput<string>[]): Disposable;
+    displayManualUpdateElanPrompt(): Promise<void>;
     private autoInstall;
+    private installElanAndDisplaySettingPrompt;
     private installElan;
+    uninstallElan(): Promise<void>;
+    private performOperation;
 }

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

@@ -1,9 +1,9 @@
 import { EventEmitter, window } from 'vscode';
-import { getPowerShellPath, isRunningTest } from '../config';
-import { ExecutionExitCode, batchExecute, displayResultError } from './batch';
-import { elanSelfUpdate } from './elan';
+import { getPowerShellPath, isRunningTest, setAlwaysAskBeforeInstallingLeanVersions } from '../config';
+import { ExecutionExitCode, displayResultError } from './batch';
+import { elanSelfUninstall, elanSelfUpdate, elanVersion, isElanEagerResolutionVersion } from './elan';
 import { logger } from './logger';
-import { displayError, displayErrorWithOptionalInput, displayNotificationWithInput, } from './notifs';
+import { displayNotification, displayNotificationWithInput, displayNotificationWithOptionalInput, displayStickyNotificationWithOptionalInput, } from './notifs';
 export class LeanVersion {
     version;
     error;
@@ -13,11 +13,8 @@ export class LeanInstaller {
     leanInstallerWindows = 'https://raw.githubusercontent.com/leanprover/elan/master/elan-init.ps1';
     outputChannel;
     prompting = false;
-    installing = false;
+    pendingOperation;
     freshInstallDefaultToolchain;
-    elanDefaultToolchain = ''; // the default toolchain according to elan (toolchain marked with '(default)')
-    workspaceSuffix = '(workspace override)';
-    defaultSuffix = '(default)';
     promptUser = true;
     // This event is raised whenever a version change happens.
     // The event provides the workspace Uri where the change happened.
@@ -57,154 +54,274 @@ export class LeanInstaller {
         const finalizer = () => {
             this.prompting = false;
         };
-        displayErrorWithOptionalInput(message, 'Restart Lean', () => this.installChangedEmitter.fire(packageUri), finalizer);
+        displayNotificationWithOptionalInput('Error', message, [{ input: 'Restart Lean', action: () => this.installChangedEmitter.fire(packageUri) }], finalizer);
     }
     handleLakeFileChanged(packageUri) {
         void this.showRestartPromptAndRestart('Lake file configuration changed', packageUri);
     }
-    removeSuffix(version) {
-        let s = version;
-        const suffixes = [this.defaultSuffix, this.workspaceSuffix];
-        suffixes.forEach(suffix => {
-            if (s.endsWith(suffix)) {
-                s = s.substr(0, s.length - suffix.length);
-            }
-        });
-        return s.trim();
+    installElanPrompt(reason) {
+        let message;
+        if (reason !== undefined) {
+            message = `${reason} Do you wish to install Lean's version manager Elan?`;
+        }
+        else {
+            message = "This command will install Lean's version manager Elan.\n\n" + 'Do you wish to proceed?';
+        }
+        const item = 'Install Elan';
+        return { message, item };
     }
-    async getElanDefaultToolchain(packageUri) {
-        if (this.elanDefaultToolchain) {
-            return this.elanDefaultToolchain;
+    async displayInstallElanPromptWithItems(severity, reason, otherItems = [], defaultItem) {
+        if (!this.getPromptUser()) {
+            // Used in tests
+            await this.autoInstall();
+            return { kind: 'InstallElan', success: true };
         }
-        const toolChains = await this.elanListToolChains(packageUri);
-        let result = '';
-        toolChains.forEach(s => {
-            if (s.endsWith(this.defaultSuffix)) {
-                result = this.removeSuffix(s);
-            }
-        });
-        this.elanDefaultToolchain = result;
-        return result;
-    }
-    async elanListToolChains(packageUri) {
-        try {
-            const cmd = 'elan';
-            const options = ['toolchain', 'list'];
-            const cwd = packageUri.scheme === 'file' ? packageUri.fsPath : undefined;
-            const stdout = (await batchExecute(cmd, options, cwd)).stdout;
-            if (!stdout) {
-                throw new Error('elan toolchain list returned no output.');
-            }
-            const result = [];
-            stdout.split(/\r?\n/).forEach(s => {
-                s = s.trim();
-                if (s !== '') {
-                    result.push(s);
-                }
-            });
-            return result;
+        const p = this.installElanPrompt(reason);
+        const choice = await displayNotificationWithInput(severity, p.message, [p.item, ...otherItems], defaultItem);
+        if (choice === undefined) {
+            return undefined;
         }
-        catch (err) {
-            return [`${err}`];
+        if (choice === p.item) {
+            return { kind: 'InstallElan', success: (await this.installElanAndDisplaySettingPrompt()) === 'Success' };
         }
+        return { kind: 'OtherItem', choice };
     }
-    async hasElan() {
-        try {
-            const options = ['--version'];
-            const result = await batchExecute('elan', options);
-            const filterVersion = /elan (\d+)\.\d+\..+/;
-            const match = filterVersion.exec(result.stdout);
-            return match !== null;
+    async displayInstallElanPrompt(severity, reason) {
+        const r = await this.displayInstallElanPromptWithItems(severity, reason);
+        if (r !== undefined && r.kind === 'InstallElan') {
+            return r.success;
         }
-        catch (err) {
-            return false;
+        return false;
+    }
+    displayStickyInstallElanPrompt(severity, reason, 
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    options, otherItems = []) {
+        const p = this.installElanPrompt(reason);
+        const installElanItem = {
+            input: p.item,
+            continueDisplaying: false,
+            action: async () => {
+                await this.installElanAndDisplaySettingPrompt();
+            },
+        };
+        return displayStickyNotificationWithOptionalInput(severity, p.message, options, [
+            installElanItem,
+            ...otherItems,
+        ]);
+    }
+    updateElanPrompt(mode) {
+        switch (mode.kind) {
+            case 'Manual':
+                return {
+                    message: "This command will update Lean's version manager Elan to its most recent version.\n\n" +
+                        'Do you wish to proceed?',
+                    item: 'Update Elan',
+                };
+            case 'Outdated':
+                return {
+                    message: `Lean's version manager Elan is outdated: the installed version is ${mode.versions.currentVersion.toString()}, but a version of ${mode.versions.recommendedVersion.toString()} is recommended.\n\n` +
+                        'Do you wish to update Elan?',
+                    item: 'Update Elan',
+                };
         }
     }
-    async displayInstallElanPrompt(severity, reason) {
-        if (!this.getPromptUser()) {
-            // Used in tests
-            await this.autoInstall();
-            return true;
+    async displayElanUpdateSuccessfulPrompt(currentVersion) {
+        if (isElanEagerResolutionVersion(currentVersion)) {
+            displayNotification('Information', 'Elan update successful!');
+            return;
         }
-        const reasonPrefix = reason ? reason + ' ' : '';
-        const installElanItem = 'Install Elan and Lean 4';
-        const installElanChoice = await displayNotificationWithInput(severity, reasonPrefix + "Do you want to install Lean's version manager Elan and a recent stable version of Lean 4?", installElanItem);
-        if (installElanChoice === undefined) {
-            return false;
+        const prompt = 'Elan update successful!\n\n' +
+            'Do you want Elan in VS Code to continue downloading and installing Lean versions automatically, or would you prefer it to ask for confirmation before downloading and installing new Lean versions?\n' +
+            'Asking for confirmation is especially desirable if you are ever using a limited internet data plan or your internet connection tends to be slow, whereas automatic installs are less tedious on fast and unlimited internet connections.';
+        const choice = await displayNotificationWithInput('Information', prompt, ['Always Ask For Confirmation'], 'Install Lean Versions Automatically');
+        if (choice === 'Always Ask For Confirmation') {
+            await setAlwaysAskBeforeInstallingLeanVersions(true);
+        }
+        if (choice === 'Install Lean Versions Automatically') {
+            await setAlwaysAskBeforeInstallingLeanVersions(false);
         }
-        await this.installElan();
-        return true;
     }
-    async displayUpdateElanPrompt(severity, currentVersion, recommendedVersion) {
-        const updateElanItem = 'Update Elan';
-        const updateElanChoice = await displayNotificationWithInput(severity, `Lean's version manager Elan is outdated: the installed version is ${currentVersion.toString()}, but a version of ${recommendedVersion.toString()} is recommended. Do you want to update Elan?`, updateElanItem);
-        if (updateElanChoice === undefined) {
+    async updateElan(currentVersion) {
+        const r = await this.performOperation('Update', async () => {
+            if (currentVersion.compare('3.1.0') === 0) {
+                // `elan self update` was broken in elan 3.1.0, so we need to take a different approach to updating elan here.
+                const installElanResult = await this.installElanAndDisplaySettingPrompt();
+                if (installElanResult !== 'Success') {
+                    return false;
+                }
+                await this.displayElanUpdateSuccessfulPrompt(currentVersion);
+                return true;
+            }
+            const elanSelfUpdateResult = await elanSelfUpdate(this.outputChannel, 'Update Elan');
+            if (elanSelfUpdateResult.exitCode !== ExecutionExitCode.Success) {
+                displayResultError(elanSelfUpdateResult, "Cannot update Elan. If you suspect that this is due to the way that you have set up Elan (e.g. from a package repository that ships an outdated version of Elan), you can disable these warnings using the 'Lean4: Show Setup Warnings' setting under 'File' > 'Preferences' > 'Settings'.");
+                return false;
+            }
+            await this.displayElanUpdateSuccessfulPrompt(currentVersion);
+            return true;
+        });
+        if (r === 'PendingOperation') {
             return false;
         }
-        if (currentVersion.compare('3.1.0') === 0) {
-            // `elan self update` was broken in elan 3.1.0, so we need to take a different approach to updating elan here.
-            const installElanResult = await this.installElan();
-            return installElanResult === 'Success';
+        return r;
+    }
+    async displayUpdateElanPromptWithItems(severity, mode, otherItems = [], defaultItem) {
+        const p = this.updateElanPrompt(mode);
+        const choice = await displayNotificationWithInput(severity, p.message, [p.item, ...otherItems], defaultItem);
+        if (choice === undefined) {
+            return undefined;
+        }
+        if (choice === p.item) {
+            return { kind: 'UpdateElan', success: await this.updateElan(mode.versions.currentVersion) };
         }
-        const elanSelfUpdateResult = await elanSelfUpdate(this.outputChannel);
-        if (elanSelfUpdateResult.exitCode !== ExecutionExitCode.Success) {
-            displayResultError(elanSelfUpdateResult, "Cannot update Elan. If you suspect that this is due to the way that you have set up Elan (e.g. from a package repository that ships an outdated version of Elan), you can disable these warnings using the 'Lean4: Show Setup Warnings' setting under 'File' > 'Preferences' > 'Settings'.");
-            return false;
+        return { kind: 'OtherItem', choice };
+    }
+    async displayUpdateElanPrompt(severity, mode) {
+        const r = await this.displayUpdateElanPromptWithItems(severity, mode);
+        if (r !== undefined && r.kind === 'UpdateElan') {
+            return r.success;
+        }
+        return false;
+    }
+    displayStickyUpdateElanPrompt(severity, mode, 
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    options, otherItems = []) {
+        const p = this.updateElanPrompt(mode);
+        const updateElanItem = {
+            input: p.item,
+            continueDisplaying: false,
+            action: async () => {
+                await this.updateElan(mode.versions.currentVersion);
+            },
+        };
+        return displayStickyNotificationWithOptionalInput(severity, p.message, options, [updateElanItem, ...otherItems]);
+    }
+    async displayManualUpdateElanPrompt() {
+        const versionResult = await elanVersion();
+        switch (versionResult.kind) {
+            case 'Success':
+                await this.displayUpdateElanPrompt('Information', {
+                    kind: 'Manual',
+                    versions: { currentVersion: versionResult.version },
+                });
+                break;
+            case 'ElanNotInstalled':
+                displayNotification('Error', 'Elan is not installed.');
+                break;
+            case 'ExecutionError':
+                displayNotification('Error', `Error while determining current Elan version: ${versionResult.message}`);
+                break;
         }
-        return true;
     }
     async autoInstall() {
         logger.log('[LeanInstaller] Installing Elan ...');
         await this.installElan();
         logger.log('[LeanInstaller] Elan installed');
     }
+    async installElanAndDisplaySettingPrompt() {
+        const r = await this.installElan();
+        if (r !== 'Success') {
+            return r;
+        }
+        const prompt = 'Elan installation successful!\n\n' +
+            'Do you want Elan in VS Code to download and install Lean versions automatically, or would you prefer it to ask for confirmation before downloading and installing new Lean versions?\n' +
+            'Asking for confirmation is especially desirable if you are ever using a limited internet data plan or your internet connection tends to be slow, whereas automatic installs are less tedious on fast and unlimited internet connections.';
+        const choice = await displayNotificationWithInput('Information', prompt, ['Always Ask For Confirmation'], 'Install Lean Versions Automatically');
+        if (choice === 'Always Ask For Confirmation') {
+            await setAlwaysAskBeforeInstallingLeanVersions(true);
+        }
+        if (choice === 'Install Lean Versions Automatically') {
+            await setAlwaysAskBeforeInstallingLeanVersions(false);
+        }
+        return r;
+    }
     async installElan() {
-        if (this.installing) {
-            displayError('Elan is already being installed. Please wait until the installation has finished.');
-            return 'PendingInstallation';
-        }
-        this.installing = true;
-        const terminalName = 'Lean installation via elan';
-        let terminalOptions = { name: terminalName };
-        if (process.platform === 'win32') {
-            terminalOptions = { name: terminalName, shellPath: getPowerShellPath() };
-        }
-        const terminal = window.createTerminal(terminalOptions);
-        terminal.show();
-        // We register a listener, to restart the Lean extension once elan has finished.
-        const resultPromise = new Promise(function (resolve, reject) {
-            window.onDidCloseTerminal(async (t) => {
-                if (t === terminal) {
-                    resolve(true);
-                }
-                else {
-                    logger.log('[LeanInstaller] ignoring terminal closed: ' + t.name + ', waiting for: ' + terminalName);
-                }
+        return await this.performOperation('Install', async () => {
+            const terminalName = 'Lean installation via elan';
+            let terminalOptions = { name: terminalName };
+            if (process.platform === 'win32') {
+                terminalOptions = { name: terminalName, shellPath: getPowerShellPath() };
+            }
+            const terminal = window.createTerminal(terminalOptions);
+            terminal.show();
+            // We register a listener, to restart the Lean extension once elan has finished.
+            const resultPromise = new Promise(function (resolve, reject) {
+                window.onDidCloseTerminal(async (t) => {
+                    if (t === terminal) {
+                        resolve(true);
+                    }
+                    else {
+                        logger.log('[LeanInstaller] ignoring terminal closed: ' + t.name + ', waiting for: ' + terminalName);
+                    }
+                });
             });
+            if (process.platform === 'win32') {
+                terminal.sendText(`Start-BitsTransfer -Source "${this.leanInstallerWindows}" -Destination "elan-init.ps1"\r\n` +
+                    'Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process\r\n' +
+                    `$rc = .\\elan-init.ps1 -NoPrompt 1 -DefaultToolchain ${this.freshInstallDefaultToolchain}\r\n` +
+                    'Write-Host "elan-init returned [$rc]"\r\n' +
+                    'del .\\elan-init.ps1\r\n' +
+                    'if ($rc -ne 0) {\r\n' +
+                    '    Read-Host -Prompt "Press ENTER to continue"\r\n' +
+                    '}\r\n' +
+                    'exit\r\n');
+            }
+            else {
+                const elanArgs = `-y --default-toolchain ${this.freshInstallDefaultToolchain}`;
+                const prompt = '(echo && read -n 1 -s -r -p "Install failed, press ENTER to continue...")';
+                terminal.sendText(`bash -c 'curl ${this.leanInstallerLinux} -sSf | sh -s -- ${elanArgs} || ${prompt}' && exit `);
+            }
+            const result = await resultPromise;
+            if (!result) {
+                displayNotification('Error', 'Elan installation failed. Check the terminal output for details.');
+                return 'InstallationFailed';
+            }
+            return 'Success';
+        });
+    }
+    async uninstallElan() {
+        await this.performOperation('Uninstall', async () => {
+            const prompt = "This command will uninstall Lean's version manager Elan and all installed Lean versions.\n\n" +
+                'Do you wish to proceed?';
+            const choice = await displayNotificationWithInput('Information', prompt, ['Proceed']);
+            if (choice !== 'Proceed') {
+                return;
+            }
+            const r = await elanSelfUninstall(this.outputChannel, 'Uninstall Elan');
+            switch (r.exitCode) {
+                case ExecutionExitCode.Success:
+                    displayNotification('Information', 'Elan uninstalled successfully.');
+                    break;
+                case ExecutionExitCode.CannotLaunch:
+                    displayNotification('Error', 'Elan is not installed.');
+                    break;
+                case ExecutionExitCode.ExecutionError:
+                    displayNotification('Error', `Error while installing Elan: ${r.combined}`);
+                    break;
+                case ExecutionExitCode.Cancelled:
+                    displayNotification('Information', 'Uninstalling Elan cancelled.');
+            }
         });
-        if (process.platform === 'win32') {
-            terminal.sendText(`Start-BitsTransfer -Source "${this.leanInstallerWindows}" -Destination "elan-init.ps1"\r\n` +
-                'Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process\r\n' +
-                `$rc = .\\elan-init.ps1 -NoPrompt 1 -DefaultToolchain ${this.freshInstallDefaultToolchain}\r\n` +
-                'Write-Host "elan-init returned [$rc]"\r\n' +
-                'del .\\elan-init.ps1\r\n' +
-                'if ($rc -ne 0) {\r\n' +
-                '    Read-Host -Prompt "Press ENTER to continue"\r\n' +
-                '}\r\n' +
-                'exit\r\n');
+    }
+    async performOperation(kind, op) {
+        switch (this.pendingOperation) {
+            case 'Install':
+                displayNotification('Error', 'Elan is being installed. Please wait until the installation has finished.');
+                return 'PendingOperation';
+            case 'Update':
+                displayNotification('Error', 'Elan is being updated. Please wait until the update has finished.');
+                return 'PendingOperation';
+            case 'Uninstall':
+                displayNotification('Error', 'Elan is being uninstalled. Please wait until the deinstallation has finished.');
+                return 'PendingOperation';
+            case undefined:
+                this.pendingOperation = kind;
+                try {
+                    return await op();
+                }
+                finally {
+                    this.pendingOperation = undefined;
+                }
         }
-        else {
-            const elanArgs = `-y --default-toolchain ${this.freshInstallDefaultToolchain}`;
-            const prompt = '(echo && read -n 1 -s -r -p "Install failed, press ENTER to continue...")';
-            terminal.sendText(`bash -c 'curl ${this.leanInstallerLinux} -sSf | sh -s -- ${elanArgs} || ${prompt}' && exit `);
-        }
-        const result = await resultPromise;
-        this.elanDefaultToolchain = this.freshInstallDefaultToolchain;
-        this.installing = false;
-        if (!result) {
-            displayError('Elan installation failed. Check the terminal output for details.');
-            return 'InstallationFailed';
-        }
-        return 'Success';
     }
 }

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

@@ -1,24 +1,29 @@
+import { Disposable } from 'vscode';
 export type NotificationSeverity = 'Information' | 'Warning' | 'Error';
+export declare function setStickyNotificationActiveButHidden(isActiveButHidden: boolean): Promise<void>;
+export type StickyNotificationOptions<T> = {
+    onInput: (lastChoice: T, continueDisplaying: boolean) => Promise<boolean>;
+    onDisplay: () => Promise<void>;
+};
+export declare function displayActiveStickyNotification(): void;
 export declare function displayNotification(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithInput<T extends string>(severity: NotificationSeverity, message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayNotificationWithOptionalInput<T extends string>(severity: NotificationSeverity, message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithOutput(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithSetupGuide(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayError(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayErrorWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayWarning(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarning(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayWarningWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayWarningWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayWarningWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarningWithOutput(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayWarningWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarningWithSetupGuide(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayInformation(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayInformationWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
+export declare function displayStickyNotification(severity: NotificationSeverity, message: string, options: StickyNotificationOptions<void>): Disposable;
+export declare function displayNotificationWithInput<T extends string>(severity: NotificationSeverity, message: string, items: T[], defaultItem?: T | undefined): Promise<T | undefined>;
+export declare function displayModalNotification(severity: NotificationSeverity, message: string): Promise<void>;
+export type Input<T> = {
+    input: T;
+    action: () => void;
+};
+export declare function displayNotificationWithOptionalInput<T extends string>(severity: NotificationSeverity, message: string, inputs: Input<T>[], finalizer?: (() => void) | undefined): void;
+export type StickyInput<T> = {
+    input: T;
+    continueDisplaying: boolean;
+    action: () => Promise<void>;
+};
+export declare function displayStickyNotificationWithOptionalInput<T extends string>(severity: NotificationSeverity, message: string, options: StickyNotificationOptions<T>, inputs: StickyInput<T>[]): Disposable;
+export declare function displayNotificationWithOutput(severity: NotificationSeverity, message: string, otherInputs?: Input<string>[], finalizer?: (() => void) | undefined): void;
+export declare function displayModalNotificationWithOutput(severity: NotificationSeverity, message: string, otherItems?: string[], defaultItem?: string | undefined): Promise<'Show Output' | string | undefined>;
+export declare function displayStickyNotificationWithOutput(severity: NotificationSeverity, message: string, options: StickyNotificationOptions<'Show Output' | string>, otherInputs?: StickyInput<string>[]): Disposable;
+export declare function displayNotificationWithSetupGuide(severity: NotificationSeverity, message: string, otherInputs?: Input<string>[], finalizer?: (() => void) | undefined): void;
+export declare function displayStickyNotificationWithSetupGuide(severity: NotificationSeverity, message: string, options: StickyNotificationOptions<'Open Setup Guide' | string>, otherInputs?: StickyInput<string>[]): Disposable;
+export declare function displayModalNotificationWithSetupGuide(severity: NotificationSeverity, message: string, otherItems?: string[], defaultItem?: string | undefined): Promise<'Open Setup Guide' | string | undefined>;