lean4monaco 1.0.46 → 1.1.0

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

@@ -0,0 +1,2 @@
+export declare function displayInternalError(scope: string, e: any): Promise<void>;
+export declare function displayInternalErrorsIn<T>(scope: string, f: () => Promise<T>): Promise<T>;

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.d.ts

@@ -0,0 +1,34 @@
+import { ExtensionContext, OutputChannel } from 'vscode';
+import { ExecutionResult } from './batch';
+import { FileUri } from './exturi';
+export type ToolchainUpdateMode = 'UpdateAutomatically' | 'PromptAboutUpdate' | 'DoNotUpdate';
+export type ToolchainDecisionOptions = {
+    channel: OutputChannel | undefined;
+    cwdUri: FileUri | undefined;
+    context: string | undefined;
+    toolchainUpdateMode: ToolchainUpdateMode;
+    toolchain?: string | undefined;
+};
+export type LeanCommandOptions = ToolchainDecisionOptions & {
+    waitingPrompt: string;
+    translator?: ((line: string) => string | undefined) | undefined;
+};
+export declare class LeanCommandRunner {
+    private stickyUpdateDecisions;
+    private runCmd;
+    private analyzeElanStateDumpWithoutNetResult;
+    private analyzeElanDumpStateWithNetResult;
+    decideToolchain(options: ToolchainDecisionOptions): Promise<{
+        kind: 'RunWithActiveToolchain';
+    } | {
+        kind: 'RunWithSpecificToolchain';
+        toolchain: string;
+    } | {
+        kind: 'Error';
+        message: string;
+    }>;
+    runLeanCommand(executablePath: string, args: string[], options: LeanCommandOptions): Promise<ExecutionResult>;
+}
+export declare let leanRunner: LeanCommandRunner;
+/** Must be called at the very start when the extension is activated so that `leanRunner` is defined. */
+export declare function registerLeanCommandRunner(context: ExtensionContext): void;

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

@@ -0,0 +1,249 @@
+import path from 'path';
+import { alwaysAskBeforeInstallingLeanVersions } from '../config';
+import { batchExecuteWithProgress, ExecutionExitCode } from './batch';
+import { elanDumpStateWithNet, elanDumpStateWithoutNet, elanInstallToolchain, ElanToolchains, ElanUnresolvedToolchain, } from './elan';
+import { displayNotification, displayNotificationWithInput } from './notifs';
+function shouldUpdateToolchainAutomatically(mode) {
+    return !alwaysAskBeforeInstallingLeanVersions() && mode === 'UpdateAutomatically';
+}
+function overrideReason(activeOverride) {
+    switch (activeOverride?.kind) {
+        case undefined:
+            return undefined;
+        case 'Environment':
+            return undefined;
+        case 'Manual':
+            return `set by \`elan override\` in folder '${activeOverride.directoryPath.baseName()}'`;
+        case 'ToolchainFile':
+            return `of Lean project '${path.dirname(activeOverride.toolchainPath.fsPath)}'`;
+        case 'LeanpkgFile':
+            return `of Lean project '${path.dirname(activeOverride.leanpkgPath.fsPath)}'`;
+        case 'ToolchainDirectory':
+            return `of Lean project '${activeOverride.directoryPath.fsPath}'`;
+    }
+}
+function leanNotInstalledError(activeOverride, unresolvedActiveToolchain) {
+    const or = overrideReason(activeOverride);
+    const formattedOverride = or !== undefined ? ' ' + or : '';
+    if (unresolvedActiveToolchain.fromChannel !== undefined) {
+        const prefix = activeOverride === undefined ? 'default ' : '';
+        return `No Lean version for ${prefix}release channel '${ElanUnresolvedToolchain.toolchainName(unresolvedActiveToolchain)}'${formattedOverride} is installed.`;
+    }
+    else {
+        const prefix = activeOverride === undefined ? 'Default ' : '';
+        return `${prefix}Lean version '${ElanUnresolvedToolchain.toolchainName(unresolvedActiveToolchain)}'${formattedOverride} is not installed.`;
+    }
+}
+function installationPrompt(activeOverride, unresolvedActiveToolchain) {
+    const error = leanNotInstalledError(activeOverride, unresolvedActiveToolchain);
+    if (unresolvedActiveToolchain.fromChannel !== undefined) {
+        return `${error}\n\n` + 'Do you wish to install one?';
+    }
+    else {
+        return `${error}\n\n` + 'Do you wish to install it?';
+    }
+}
+function updatePrompt(activeOverride, releaseChannel, cachedActiveToolchain, resolvedActiveToolchain) {
+    const prefix = activeOverride === undefined ? 'default ' : '';
+    const reason = overrideReason(activeOverride);
+    return (`Installed Lean version '${cachedActiveToolchain}' for ${prefix}release channel '${releaseChannel}'${reason !== undefined ? ' ' + reason : ''} is outdated.\n\n` +
+        `Do you wish to install the new Lean version '${resolvedActiveToolchain}' or continue using the outdated Lean version?`);
+}
+function updateDecisionKey(cwdUri, cachedToolchain) {
+    return JSON.stringify({
+        cwdUri,
+        cachedToolchain,
+    });
+}
+export class LeanCommandRunner {
+    stickyUpdateDecisions = new Map();
+    async runCmd(executablePath, args, options, toolchain) {
+        const toolchainOverride = toolchain ?? options.toolchain;
+        if (toolchainOverride !== undefined) {
+            args = [`+${toolchainOverride}`, ...args];
+        }
+        return await batchExecuteWithProgress(executablePath, args, options.context, options.waitingPrompt, {
+            cwd: options.cwdUri?.fsPath,
+            channel: options.channel,
+            translator: options.translator,
+            allowCancellation: true,
+        });
+    }
+    async analyzeElanStateDumpWithoutNetResult(channel, context, r) {
+        const runWithActiveToolchain = { kind: 'RunWithActiveToolchain' };
+        let elanState;
+        switch (r.kind) {
+            case 'Success':
+                elanState = r.state;
+                break;
+            case 'ElanNotFound':
+                return runWithActiveToolchain;
+            case 'ExecutionError':
+                return runWithActiveToolchain;
+        }
+        const unresolvedToolchain = ElanToolchains.unresolvedToolchain(elanState.toolchains);
+        const toolchainResolutionResult = elanState.toolchains.resolvedActive;
+        if (unresolvedToolchain === undefined || toolchainResolutionResult === undefined) {
+            return runWithActiveToolchain;
+        }
+        if (unresolvedToolchain.kind === 'Local') {
+            return runWithActiveToolchain;
+        }
+        const cachedToolchain = toolchainResolutionResult.cachedToolchain;
+        if (cachedToolchain === undefined) {
+            const installNewToolchain = async () => {
+                const elanInstallToolchainResult = await elanInstallToolchain(channel, context, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain));
+                switch (elanInstallToolchainResult.kind) {
+                    case 'Success':
+                    case 'ElanNotFound':
+                    case 'ToolchainAlreadyInstalled':
+                        return runWithActiveToolchain;
+                    case 'Error':
+                        return {
+                            kind: 'Error',
+                            message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain) + ` Reason: Installation failed. Error: ${elanInstallToolchainResult.message}`,
+                        };
+                    case 'Cancelled':
+                        return {
+                            kind: 'Error',
+                            message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain) + ' Reason: Installation was cancelled.',
+                        };
+                }
+            };
+            if (!alwaysAskBeforeInstallingLeanVersions()) {
+                return await installNewToolchain();
+            }
+            const choice = await displayNotificationWithInput('Information', installationPrompt(elanState.toolchains.activeOverride?.reason, unresolvedToolchain), ['Install Version']);
+            if (choice === undefined) {
+                return {
+                    kind: 'Error',
+                    message: leanNotInstalledError(elanState.toolchains.activeOverride?.reason, unresolvedToolchain),
+                };
+            }
+            choice;
+            return await installNewToolchain();
+        }
+        if (unresolvedToolchain.fromChannel === undefined) {
+            return runWithActiveToolchain;
+        }
+        return { kind: 'CheckForToolchainUpdate', cachedToolchain };
+    }
+    async analyzeElanDumpStateWithNetResult(channel, context, toolchainUpdateMode, cachedToolchain, r) {
+        const runWithActiveToolchain = { kind: 'RunWithActiveToolchain' };
+        const runWithCachedToolchain = warning => ({
+            kind: 'RunWithCachedToolchain',
+            warning,
+        });
+        let elanState;
+        switch (r.kind) {
+            case 'Success':
+                elanState = r.state;
+                break;
+            case 'ElanNotFound':
+                return runWithActiveToolchain;
+            case 'ExecutionError':
+                return runWithActiveToolchain;
+            case 'Cancelled':
+                return runWithCachedToolchain(`Lean version information query was cancelled, falling back to installed Lean version '${cachedToolchain}'.`);
+        }
+        const unresolvedToolchain = ElanToolchains.unresolvedToolchain(elanState.toolchains);
+        const toolchainResolutionResult = elanState.toolchains.resolvedActive;
+        if (unresolvedToolchain === undefined || toolchainResolutionResult === undefined) {
+            return runWithActiveToolchain;
+        }
+        if (unresolvedToolchain.kind === 'Local' || unresolvedToolchain.fromChannel === undefined) {
+            return runWithActiveToolchain;
+        }
+        const resolvedToolchainResult = toolchainResolutionResult.resolvedToolchain;
+        let resolvedToolchain;
+        switch (resolvedToolchainResult.kind) {
+            case 'Error':
+                return runWithCachedToolchain(`Could not fetch Lean version information, falling back to installed Lean version '${cachedToolchain}'. Error: ${resolvedToolchainResult.message}`);
+            case 'Ok':
+                resolvedToolchain = resolvedToolchainResult.value;
+                break;
+        }
+        const willActiveToolchainBeUpdated = cachedToolchain !== resolvedToolchain;
+        if (!willActiveToolchainBeUpdated) {
+            return runWithActiveToolchain;
+        }
+        const isResolvedToolchainAlreadyInstalled = elanState.toolchains.installed.has(resolvedToolchain);
+        if (isResolvedToolchainAlreadyInstalled) {
+            return runWithActiveToolchain;
+        }
+        const updateToolchain = async () => {
+            const elanInstallToolchainResult = await elanInstallToolchain(channel, context, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain));
+            switch (elanInstallToolchainResult.kind) {
+                case 'Success':
+                case 'ElanNotFound':
+                case 'ToolchainAlreadyInstalled':
+                    return runWithActiveToolchain;
+                case 'Error':
+                    return runWithCachedToolchain(`Could not update Lean version, falling back to installed Lean version '${cachedToolchain}'. Error: ${elanInstallToolchainResult.message}`);
+                case 'Cancelled':
+                    return runWithCachedToolchain(`Lean version update was cancelled, falling back to installed Lean version '${cachedToolchain}'.`);
+            }
+        };
+        if (shouldUpdateToolchainAutomatically(toolchainUpdateMode)) {
+            return await updateToolchain();
+        }
+        const choice = await displayNotificationWithInput('Information', updatePrompt(elanState.toolchains.activeOverride?.reason, ElanUnresolvedToolchain.toolchainName(unresolvedToolchain), cachedToolchain, resolvedToolchain), ['Update Lean Version'], 'Use Old Version');
+        if (choice === undefined || choice === 'Use Old Version') {
+            return runWithCachedToolchain(undefined);
+        }
+        choice;
+        return await updateToolchain();
+    }
+    async decideToolchain(options) {
+        const elanStateDumpWithoutNetResult = await elanDumpStateWithoutNet(options.cwdUri, options.toolchain);
+        const withoutNetAnalysisResult = await this.analyzeElanStateDumpWithoutNetResult(options.channel, options.context, elanStateDumpWithoutNetResult);
+        if (withoutNetAnalysisResult.kind !== 'CheckForToolchainUpdate') {
+            return withoutNetAnalysisResult;
+        }
+        const cachedToolchain = withoutNetAnalysisResult.cachedToolchain;
+        const key = updateDecisionKey(options.cwdUri, cachedToolchain);
+        if (options.toolchainUpdateMode === 'DoNotUpdate' ||
+            (!shouldUpdateToolchainAutomatically(options.toolchainUpdateMode) &&
+                this.stickyUpdateDecisions.get(key) === 'DoNotUpdate')) {
+            return { kind: 'RunWithSpecificToolchain', toolchain: cachedToolchain };
+        }
+        const elanStateDumpWithNetResult = await elanDumpStateWithNet(options.cwdUri, options.context, options.toolchain);
+        const withNetAnalysisResult = await this.analyzeElanDumpStateWithNetResult(options.channel, options.context, options.toolchainUpdateMode, cachedToolchain, elanStateDumpWithNetResult);
+        if (withNetAnalysisResult.kind === 'RunWithCachedToolchain') {
+            this.stickyUpdateDecisions.set(key, 'DoNotUpdate');
+            if (withNetAnalysisResult.warning !== undefined) {
+                displayNotification('Warning', withNetAnalysisResult.warning);
+            }
+            return { kind: 'RunWithSpecificToolchain', toolchain: cachedToolchain };
+        }
+        return withNetAnalysisResult;
+    }
+    async runLeanCommand(executablePath, args, options) {
+        const toolchainDecision = await this.decideToolchain(options);
+        if (toolchainDecision.kind === 'Error') {
+            return {
+                exitCode: ExecutionExitCode.ExecutionError,
+                stdout: toolchainDecision.message,
+                stderr: '',
+                combined: toolchainDecision.message,
+            };
+        }
+        if (toolchainDecision.kind === 'RunWithActiveToolchain') {
+            return await this.runCmd(executablePath, args, options, undefined);
+        }
+        toolchainDecision.kind;
+        return await this.runCmd(executablePath, args, options, toolchainDecision.toolchain);
+    }
+}
+export let leanRunner;
+/** Must be called at the very start when the extension is activated so that `leanRunner` is defined. */
+export function registerLeanCommandRunner(context) {
+    leanRunner = new LeanCommandRunner();
+    context.subscriptions.push({
+        dispose: () => {
+            const u = undefined;
+            // Implicit invariant: When the extension deactivates, `leanRunner` is not called after this assignment.
+            leanRunner = u;
+        },
+    });
+}

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

@@ -0,0 +1,83 @@
+import { Disposable, ExtensionContext, TextDocument, TextEditor, TextEditorEdit, TextEditorSelectionChangeEvent } from 'vscode';
+import { ExtUri } from './exturi';
+export declare class LeanDocument {
+    readonly doc: TextDocument;
+    readonly extUri: ExtUri;
+    constructor(doc: TextDocument, extUri: ExtUri);
+    equals(other: LeanDocument): boolean;
+    equalsTextDocument(other: TextDocument): boolean;
+    static equalsWithUndefined(a: LeanDocument | undefined, b: LeanDocument | undefined): boolean;
+}
+export declare class LeanEditor {
+    readonly editor: TextEditor;
+    readonly documentExtUri: ExtUri;
+    constructor(editor: TextEditor, documentExtUri: ExtUri);
+    equals(other: LeanEditor): boolean;
+    equalsTextEditor(other: TextEditor): boolean;
+    static equalsWithUndefined(a: LeanEditor | undefined, b: LeanEditor | undefined): boolean;
+}
+export declare function isLeanDocument(doc: TextDocument): boolean;
+export declare function asLeanDocument(doc: TextDocument): LeanDocument | undefined;
+export declare function filterLeanDocuments(docs: readonly TextDocument[]): LeanDocument[];
+export declare function filterLeanDocument(doc: TextDocument | undefined): LeanDocument | undefined;
+export declare function isLeanEditor(editor: TextEditor): boolean;
+export declare function asLeanEditor(editor: TextEditor): LeanEditor | undefined;
+export declare function filterLeanEditors(editors: readonly TextEditor[]): LeanEditor[];
+export declare function filterLeanEditor(editor: TextEditor | undefined): LeanEditor | undefined;
+export declare class LeanEditorProvider implements Disposable {
+    private subscriptions;
+    private _visibleLeanEditors;
+    private visibleLeanEditorsByUri;
+    private readonly onDidChangeVisibleLeanEditorsEmitter;
+    readonly onDidChangeVisibleLeanEditors: import("vscode").Event<readonly LeanEditor[]>;
+    private _activeLeanEditor;
+    private readonly onDidChangeActiveLeanEditorEmitter;
+    readonly onDidChangeActiveLeanEditor: import("vscode").Event<LeanEditor | undefined>;
+    private _lastActiveLeanEditor;
+    private readonly onDidChangeLastActiveLeanEditorEmitter;
+    readonly onDidChangeLastActiveLeanEditor: import("vscode").Event<LeanEditor | undefined>;
+    private _leanDocuments;
+    private leanDocumentsByUri;
+    private readonly onDidChangeLeanDocumentsEmitter;
+    readonly onDidChangeLeanDocuments: import("vscode").Event<readonly LeanDocument[]>;
+    private readonly onDidOpenLeanDocumentEmitter;
+    readonly onDidOpenLeanDocument: import("vscode").Event<LeanDocument>;
+    private readonly onDidCloseLeanDocumentEmitter;
+    readonly onDidCloseLeanDocument: import("vscode").Event<LeanDocument>;
+    private _lastActiveLeanDocument;
+    private readonly onDidChangeLastActiveLeanDocumentEmitter;
+    readonly onDidChangeLastActiveLeanDocument: import("vscode").Event<LeanDocument | undefined>;
+    private readonly onDidRevealLeanEditorEmitter;
+    readonly onDidRevealLeanEditor: import("vscode").Event<LeanEditor>;
+    private readonly onDidConcealLeanEditorEmitter;
+    readonly onDidConcealLeanEditor: import("vscode").Event<LeanEditor>;
+    private readonly onDidChangeLeanEditorSelectionEmitter;
+    readonly onDidChangeLeanEditorSelection: import("vscode").Event<TextEditorSelectionChangeEvent>;
+    constructor();
+    private updateVisibleTextEditors;
+    private updateActiveTextEditor;
+    private updateVisibleLeanEditors;
+    private revealLeanEditors;
+    private concealLeanEditors;
+    private updateActiveLeanEditor;
+    private invalidateInvisibleLastActiveLeanEditor;
+    private updateLastActiveLeanEditor;
+    private updateLeanDocuments;
+    private openLeanDocument;
+    private closeLeanDocument;
+    private invalidateClosedLastActiveLeanDocument;
+    private updateLastActiveLeanDocument;
+    private updateTextEditorSelection;
+    get visibleLeanEditors(): readonly LeanEditor[];
+    get activeLeanEditor(): LeanEditor | undefined;
+    get lastActiveLeanEditor(): LeanEditor | undefined;
+    get leanDocuments(): readonly LeanDocument[];
+    get lastActiveLeanDocument(): LeanDocument | undefined;
+    getVisibleLeanEditorsByUri(uri: ExtUri): readonly LeanEditor[];
+    getLeanDocumentByUri(uri: ExtUri): LeanDocument | undefined;
+    registerLeanEditorCommand(command: string, callback: (leanEditor: LeanEditor, edit: TextEditorEdit, ...args: any[]) => void, thisArg?: any): Disposable;
+    dispose(): void;
+}
+export declare let lean: LeanEditorProvider;
+/** Must be called at the very start when the extension is activated so that `lean` is defined. */
+export declare function registerLeanEditorProvider(context: ExtensionContext): void;