lean4monaco 1.0.46 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupDiagnostics.js

@@ -1,19 +1,8 @@
 import { commands } from 'vscode';
 import { extUriToCwdUri } from '../utils/exturi';
-import { willUseLakeServer } from '../utils/projectInfo';
+import { displayInternalError } from '../utils/internalErrors';
 import { diagnose } from './setupDiagnoser';
-import { displayDependencySetupError, displayElanOutdatedSetupWarning, displayElanSetupError, displayElanSetupWarning, displaySetupError, displaySetupErrorWithOutput, displaySetupWarning, displaySetupWarningWithOptionalInput, displaySetupWarningWithOutput, worstPreconditionViolation, } from './setupNotifs';
-export async function checkAll(...checks) {
-    let worstViolation = 'Fulfilled';
-    for (const check of checks) {
-        const result = await check();
-        worstViolation = worstPreconditionViolation(worstViolation, result);
-        if (worstViolation === 'Fatal') {
-            return 'Fatal';
-        }
-    }
-    return worstViolation;
-}
+import { SetupNotifier, worstPreconditionViolation, } from './setupNotifs';
 const singleFileWarningMessage = `Lean 4 server is operating in restricted single file mode.
 Please open a valid Lean 4 project containing a \'lean-toolchain\' file for full functionality.
 Click the following link to learn how to set up or open Lean projects: [(Show Setup Guide)](command:lean4.docs.showSetupGuide)`;
@@ -27,124 +16,198 @@ const lean3ProjectErrorMessage = (origin, projectVersion) => `${origin} is using
 If you want to use Lean 3, disable this extension ('Extensions' in the left sidebar > Cog icon on 'lean4' > 'Disable') and install the 'lean' extension for Lean 3 support.`;
 const ancientLean4ProjectWarningMessage = (origin, projectVersion) => `${origin} is using a Lean 4 version (${projectVersion.toString()}) from before the first Lean 4 stable release (4.0.0).
 Pre-stable Lean 4 versions are increasingly less supported, so please consider updating to a newer Lean 4 version.`;
-export async function checkAreDependenciesInstalled(channel, cwdUri) {
-    const missingDeps = [];
-    if (!(await diagnose(channel, cwdUri).checkCurlAvailable())) {
-        missingDeps.push('curl');
+const oldServerFolderContainsNewServerFolderErrorMessage = (folderUri, fileUri, clientFolderUri) => `Error while starting language server: The project at '${folderUri.fsPath}' of the file '${fileUri.baseName()}' is contained inside of another project at '${clientFolderUri.fsPath}', for which a language server is already running.
+The Lean 4 VS Code extension does not support nested Lean projects.`;
+const newServerFolderContainsOldServerFolderErrorMessage = (folderUri, fileUri, clientFolderUri) => `Error while starting language server: The project at '${folderUri.fsPath}' of the file '${fileUri.baseName()}' contains another project at '${clientFolderUri.fsPath}', for which a language server is already running.
+The Lean 4 VS Code extension does not support nested Lean projects.`;
+export class SetupDiagnostics {
+    n;
+    constructor(o) {
+        this.n = new SetupNotifier(o);
     }
-    if (!(await diagnose(channel, cwdUri).checkGitAvailable())) {
-        missingDeps.push('git');
+    async checkAreDependenciesInstalled(channel, cwdUri) {
+        const missingDeps = [];
+        if (!(await diagnose({ channel, cwdUri }).checkCurlAvailable())) {
+            missingDeps.push('curl');
+        }
+        if (!(await diagnose({ channel, cwdUri }).checkGitAvailable())) {
+            missingDeps.push('git');
+        }
+        if (missingDeps.length === 0) {
+            return 'Fulfilled';
+        }
+        let missingDepMessage;
+        if (missingDeps.length === 1) {
+            missingDepMessage = `One of Lean's dependencies ('${missingDeps.at(0)}') is missing`;
+        }
+        else {
+            missingDepMessage = `Multiple of Lean's dependencies (${missingDeps.map(dep => `'${dep}'`).join(', ')}) are missing`;
+        }
+        const errorMessage = `${missingDepMessage}. Please read the Setup Guide on how to install missing dependencies and set up Lean 4.`;
+        return await this.n.displaySetupErrorWithSetupGuide(errorMessage);
     }
-    if (missingDeps.length === 0) {
-        return 'Fulfilled';
+    async checkIsLean4Installed(installer, context, cwdUri, toolchainUpdateMode) {
+        const leanVersionResult = await diagnose({
+            channel: installer.getOutputChannel(),
+            cwdUri,
+            context,
+            toolchainUpdateMode,
+        }).queryLeanVersion();
+        switch (leanVersionResult.kind) {
+            case 'Success':
+                return 'Fulfilled';
+            case 'CommandError':
+                return this.n.displaySetupErrorWithOutput(`Error while checking Lean version: ${leanVersionResult.message}`);
+            case 'Cancelled':
+                return this.n.displaySetupErrorWithOutput('Error while checking Lean version: Operation cancelled.');
+            case 'InvalidVersion':
+                return this.n.displaySetupErrorWithOutput(`Error while checking Lean version: 'lean --version' returned a version that could not be parsed: '${leanVersionResult.versionResult}'`);
+            case 'CommandNotFound':
+                return await this.n.displayElanSetupError(installer, 'Lean is not installed.');
+        }
     }
-    displayDependencySetupError(missingDeps);
-    return 'Fatal';
-}
-export async function checkIsLean4Installed(installer, cwdUri) {
-    const leanVersionResult = await diagnose(installer.getOutputChannel(), cwdUri).queryLeanVersion();
-    switch (leanVersionResult.kind) {
-        case 'Success':
-            return 'Fulfilled';
-        case 'CommandError':
-            return displaySetupErrorWithOutput(`Error while checking Lean version: ${leanVersionResult.message}`);
-        case 'InvalidVersion':
-            return displaySetupErrorWithOutput(`Error while checking Lean version: 'lean --version' returned a version that could not be parsed: '${leanVersionResult.versionResult}'`);
-        case 'CommandNotFound':
-            return await displayElanSetupError(installer, 'Lean is not installed.');
+    async checkIsElanUpToDate(installer, cwdUri, options) {
+        const elanDiagnosis = await diagnose({ channel: installer.getOutputChannel(), cwdUri }).elanVersion();
+        switch (elanDiagnosis.kind) {
+            case 'NotInstalled':
+                if (options.elanMustBeInstalled) {
+                    return await this.n.displayElanSetupError(installer, "Lean's version manager Elan is not installed.");
+                }
+                return await this.n.displayElanSetupWarning(installer, "Lean's version manager Elan is not installed. This means that the correct Lean 4 toolchain version of Lean 4 projects will not be selected or installed automatically.");
+            case 'ExecutionError':
+                return await this.n.displaySetupWarningWithOutput('Cannot determine Elan version: ' + elanDiagnosis.message);
+            case 'Outdated':
+                return await this.n.displayElanOutdatedSetupWarning(installer, elanDiagnosis.currentVersion, elanDiagnosis.recommendedVersion);
+            case 'UpToDate':
+                return 'Fulfilled';
+        }
     }
-}
-export async function checkIsElanUpToDate(installer, cwdUri, options) {
-    const elanDiagnosis = await diagnose(installer.getOutputChannel(), cwdUri).elanVersion();
-    switch (elanDiagnosis.kind) {
-        case 'NotInstalled':
-            if (options.elanMustBeInstalled) {
-                return await displayElanSetupError(installer, "Lean's version manager Elan is not installed.");
+    async checkIsValidProjectFolder(channel, folderUri) {
+        const projectSetupDiagnosis = await diagnose({ channel, cwdUri: extUriToCwdUri(folderUri) }).projectSetup();
+        switch (projectSetupDiagnosis.kind) {
+            case 'SingleFile':
+                return await this.n.displaySetupWarning(singleFileWarningMessage);
+            case 'MissingLeanToolchain':
+                const parentProjectFolder = projectSetupDiagnosis.parentProjectFolder;
+                if (parentProjectFolder === undefined) {
+                    return await this.n.displaySetupWarning(missingLeanToolchainWarningMessage);
+                }
+                else {
+                    return this.n.displaySetupWarningWithInput(missingLeanToolchainWithParentProjectWarningMessage(parentProjectFolder), [
+                        {
+                            input: 'Open Parent Directory Project',
+                            // this kills the extension host
+                            action: () => commands.executeCommand('vscode.openFolder', parentProjectFolder),
+                        },
+                    ]);
+                }
+            case 'ValidProjectSetup':
+                return 'Fulfilled';
+        }
+    }
+    async checkIsNestedProjectFolder(existingFolderUris, folderUri, fileUri, stopOtherServer) {
+        if (folderUri.scheme === 'untitled' || fileUri.scheme === 'untitled') {
+            if (existingFolderUris.some(existingFolderUri => existingFolderUri.scheme === 'untitled')) {
+                await displayInternalError('starting language server', 'Attempting to start new untitled language server while one already exists.');
+                return 'Fatal';
             }
-            return await displayElanSetupWarning(installer, "Lean's version manager Elan is not installed. This means that the correct Lean 4 toolchain version of Lean 4 projects will not be selected or installed automatically.");
-        case 'ExecutionError':
-            return await displaySetupWarningWithOutput('Cannot determine Elan version: ' + elanDiagnosis.message, {
-                modal: options.modal,
-            });
-        case 'Outdated':
-            return await displayElanOutdatedSetupWarning(installer, elanDiagnosis.currentVersion, elanDiagnosis.recommendedVersion);
-        case 'UpToDate':
             return 'Fulfilled';
-    }
-}
-export async function checkIsValidProjectFolder(channel, folderUri) {
-    const projectSetupDiagnosis = await diagnose(channel, extUriToCwdUri(folderUri)).projectSetup();
-    switch (projectSetupDiagnosis.kind) {
-        case 'SingleFile':
-            return await displaySetupWarning(singleFileWarningMessage);
-        case 'MissingLeanToolchain':
-            const parentProjectFolder = projectSetupDiagnosis.parentProjectFolder;
-            if (parentProjectFolder === undefined) {
-                return await displaySetupWarning(missingLeanToolchainWarningMessage);
+        }
+        for (const existingFolderUri of existingFolderUris) {
+            if (existingFolderUri.scheme !== 'file') {
+                continue;
             }
-            else {
-                return displaySetupWarningWithOptionalInput(missingLeanToolchainWithParentProjectWarningMessage(parentProjectFolder), 'Open Parent Directory Project', 
-                // this kills the extension host
-                () => commands.executeCommand('vscode.openFolder', parentProjectFolder));
+            if (existingFolderUri.isInFolder(folderUri)) {
+                return await this.n.displaySetupErrorWithInput(newServerFolderContainsOldServerFolderErrorMessage(folderUri, fileUri, existingFolderUri), [
+                    {
+                        input: 'Stop Other Server',
+                        continueDisplaying: false,
+                        action: () => stopOtherServer(existingFolderUri),
+                    },
+                ]);
             }
-        case 'ValidProjectSetup':
-            return 'Fulfilled';
-    }
-}
-export async function checkIsLeanVersionUpToDate(channel, folderUri, options) {
-    let origin;
-    if (options.toolchainOverride !== undefined) {
-        origin = `Project toolchain '${options.toolchainOverride}'`;
-    }
-    else if (folderUri.scheme === 'untitled') {
-        origin = 'Opened file';
-    }
-    else {
-        origin = 'Opened project';
+            if (folderUri.isInFolder(existingFolderUri)) {
+                return await this.n.displaySetupErrorWithInput(oldServerFolderContainsNewServerFolderErrorMessage(folderUri, fileUri, existingFolderUri), [
+                    {
+                        input: 'Stop Other Server',
+                        continueDisplaying: false,
+                        action: () => stopOtherServer(existingFolderUri),
+                    },
+                ]);
+            }
+        }
+        return 'Fulfilled';
     }
-    const projectLeanVersionDiagnosis = await diagnose(channel, extUriToCwdUri(folderUri), options.toolchainOverride).leanVersion();
-    switch (projectLeanVersionDiagnosis.kind) {
-        case 'NotInstalled':
-            return displaySetupErrorWithOutput("Error while checking Lean version: 'lean' command was not found.");
-        case 'ExecutionError':
-            return displaySetupErrorWithOutput(`Error while checking Lean version: ${projectLeanVersionDiagnosis.message}`);
-        case 'IsLean3Version':
-            return displaySetupError(lean3ProjectErrorMessage(origin, projectLeanVersionDiagnosis.version));
-        case 'IsAncientLean4Version':
-            return await displaySetupWarning(ancientLean4ProjectWarningMessage(origin, projectLeanVersionDiagnosis.version), {
-                modal: options.modal,
-            });
-        case 'UpToDate':
-            return 'Fulfilled';
+    async checkIsLeanVersionUpToDate(channel, context, folderUri, options) {
+        let origin;
+        if (options.toolchainOverride !== undefined) {
+            origin = `Project toolchain '${options.toolchainOverride}'`;
+        }
+        else if (folderUri.scheme === 'untitled') {
+            origin = 'Opened file';
+        }
+        else {
+            origin = 'Opened project';
+        }
+        const projectLeanVersionDiagnosis = await diagnose({
+            channel,
+            cwdUri: extUriToCwdUri(folderUri),
+            toolchain: options.toolchainOverride,
+            context,
+            toolchainUpdateMode: options.toolchainUpdateMode,
+        }).leanVersion();
+        switch (projectLeanVersionDiagnosis.kind) {
+            case 'NotInstalled':
+                return this.n.displaySetupErrorWithOutput("Error while checking Lean version: 'lean' command was not found.");
+            case 'ExecutionError':
+                return this.n.displaySetupErrorWithOutput(`Error while checking Lean version: ${projectLeanVersionDiagnosis.message}`);
+            case 'Cancelled':
+                return this.n.displaySetupErrorWithOutput('Error while checking Lean version: Operation cancelled.');
+            case 'IsLean3Version':
+                return this.n.displaySetupError(lean3ProjectErrorMessage(origin, projectLeanVersionDiagnosis.version));
+            case 'IsAncientLean4Version':
+                return await this.n.displaySetupWarning(ancientLean4ProjectWarningMessage(origin, projectLeanVersionDiagnosis.version));
+            case 'UpToDate':
+                return 'Fulfilled';
+        }
     }
-}
-export async function checkIsLakeInstalledCorrectly(channel, folderUri, options) {
-    const lakeVersionResult = await diagnose(channel, extUriToCwdUri(folderUri), options.toolchainOverride).queryLakeVersion();
-    switch (lakeVersionResult.kind) {
-        case 'CommandNotFound':
-            return displaySetupErrorWithOutput("Error while checking Lake version: 'lake' command was not found.");
-        case 'CommandError':
-            return displaySetupErrorWithOutput(`Error while checking Lake version: ${lakeVersionResult.message}`);
-        case 'InvalidVersion':
-            return displaySetupErrorWithOutput(`Error while checking Lake version: Invalid Lake version format: '${lakeVersionResult.versionResult}'`);
-        case 'Success':
-            return 'Fulfilled';
+    async checkIsLakeInstalledCorrectly(channel, context, folderUri, options) {
+        const lakeAvailabilityResult = await diagnose({
+            channel,
+            cwdUri: extUriToCwdUri(folderUri),
+            toolchain: options.toolchainOverride,
+            context,
+            toolchainUpdateMode: options.toolchainUpdateMode,
+        }).checkLakeAvailable();
+        switch (lakeAvailabilityResult.kind) {
+            case 'NotAvailable':
+                return this.n.displaySetupErrorWithOutput("Error while checking Lake availability: 'lake' command was not found.");
+            case 'Error':
+                return this.n.displaySetupErrorWithOutput(`Error while checking Lake availability: ${lakeAvailabilityResult.message}`);
+            case 'Cancelled':
+                return this.n.displaySetupErrorWithOutput('Error while checking Lake availability: Operation cancelled.');
+            case 'Available':
+                return 'Fulfilled';
+        }
     }
-}
-export async function checkIsVSCodeUpToDate() {
-    const vscodeVersionResult = diagnose(undefined, undefined).queryVSCodeVersion();
-    switch (vscodeVersionResult.kind) {
-        case 'Outdated':
-            return displaySetupWarning(`VS Code version is too out-of-date for new versions of the Lean 4 VS Code extension. The current VS Code version is ${vscodeVersionResult.currentVersion}, but at least a version of ${vscodeVersionResult.recommendedVersion} is recommended so that new versions of the Lean 4 VS Code extension can be installed.`);
-        case 'UpToDate':
-            return 'Fulfilled';
+    async checkIsVSCodeUpToDate() {
+        const vscodeVersionResult = diagnose({ channel: undefined, cwdUri: undefined }).queryVSCodeVersion();
+        switch (vscodeVersionResult.kind) {
+            case 'Outdated':
+                return await this.n.displaySetupWarning(`VS Code version is too out-of-date for new versions of the Lean 4 VS Code extension. The current VS Code version is ${vscodeVersionResult.currentVersion}, but a version of at least ${vscodeVersionResult.recommendedVersion} is recommended so that new versions of the Lean 4 VS Code extension can be installed.`);
+            case 'UpToDate':
+                return 'Fulfilled';
+        }
     }
 }
-export async function checkLean4ProjectPreconditions(channel, folderUri) {
-    return await checkAll(() => checkIsValidProjectFolder(channel, folderUri), () => checkIsLeanVersionUpToDate(channel, folderUri, { modal: false }), async () => {
-        if (!(await willUseLakeServer(folderUri))) {
-            return 'Fulfilled';
+export async function checkAll(...checks) {
+    let worstViolation = 'Fulfilled';
+    for (const check of checks) {
+        const result = await check();
+        worstViolation = worstPreconditionViolation(worstViolation, result);
+        if (worstViolation === 'Fatal') {
+            return 'Fatal';
         }
-        return await checkIsLakeInstalledCorrectly(channel, folderUri, {});
-    });
+    }
+    return worstViolation;
 }

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupNotifs.d.ts

@@ -1,27 +1,40 @@
 import { SemVer } from 'semver';
 import { LeanInstaller } from '../utils/leanInstaller';
+import { Input, StickyInput } from '../utils/notifs';
 export type PreconditionCheckResult = 'Fulfilled' | 'Warning' | 'Fatal';
 export declare function preconditionCheckResultToSeverity(result: PreconditionCheckResult): 0 | 1 | 2;
 export declare function severityToPreconditionCheckResult(severity: 0 | 1 | 2): PreconditionCheckResult;
 export declare function worstPreconditionViolation(...results: PreconditionCheckResult[]): PreconditionCheckResult;
-export type SetupWarningOptions = {
-    modal: true;
-} | {
-    modal: false;
-    finalizer?: (() => void) | undefined;
+export type SetupNotificationOptions = {
+    errorMode: {
+        mode: 'Sticky';
+        retry: () => Promise<void>;
+    } | {
+        mode: 'Modal';
+    } | {
+        mode: 'NonModal';
+    };
+    warningMode: {
+        modal: boolean;
+        proceedByDefault: boolean;
+    };
 };
-export declare function displaySetupError(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
-export declare function displaySetupErrorWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displaySetupErrorWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): PreconditionCheckResult;
-export declare function displaySetupErrorWithOutput(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
-export declare function displaySetupErrorWithSetupGuide(message: string, finalizer?: (() => void) | undefined): PreconditionCheckResult;
-export declare function displayDependencySetupError(missingDeps: string[]): PreconditionCheckResult;
-export declare function displayElanSetupError(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
-export declare function displayElanOutdatedSetupError(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;
-export declare function displaySetupWarning(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
-export declare function displaySetupWarningWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displaySetupWarningWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): PreconditionCheckResult;
-export declare function displaySetupWarningWithOutput(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
-export declare function displaySetupWarningWithSetupGuide(message: string, options?: SetupWarningOptions): Promise<PreconditionCheckResult>;
-export declare function displayElanSetupWarning(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
-export declare function displayElanOutdatedSetupWarning(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;
+export declare class SetupNotifier {
+    private options;
+    private subscriptions;
+    constructor(options: SetupNotificationOptions);
+    private error;
+    private warning;
+    displaySetupError(message: string): Promise<PreconditionCheckResult>;
+    displaySetupWarning(message: string): Promise<PreconditionCheckResult>;
+    displaySetupErrorWithInput(message: string, inputs: StickyInput<string>[]): Promise<PreconditionCheckResult>;
+    displaySetupWarningWithInput(message: string, inputs: Input<string>[]): Promise<PreconditionCheckResult>;
+    displaySetupErrorWithOutput(message: string): Promise<PreconditionCheckResult>;
+    displaySetupWarningWithOutput(message: string): Promise<PreconditionCheckResult>;
+    displaySetupErrorWithSetupGuide(message: string): Promise<PreconditionCheckResult>;
+    displaySetupWarningWithSetupGuide(message: string): Promise<PreconditionCheckResult>;
+    displayElanSetupError(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
+    displayElanSetupWarning(installer: LeanInstaller, reason: string): Promise<PreconditionCheckResult>;
+    displayElanOutdatedSetupError(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;
+    displayElanOutdatedSetupWarning(installer: LeanInstaller, currentVersion: SemVer, recommendedVersion: SemVer): Promise<PreconditionCheckResult>;
+}