lean4monaco 1.0.46 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.d.ts

@@ -1,8 +1,8 @@
-import { AbbreviationProvider, SelectionMoveMode } from '@leanprover/unicode-input';
+import { AbbreviationProvider } from '@leanprover/unicode-input';
 import { OutputChannel } from 'vscode';
 export declare class AbbreviationFeature {
     private readonly disposables;
     readonly abbreviations: AbbreviationProvider;
-    constructor(outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode);
+    constructor(outputChannel: OutputChannel);
     dispose(): void;
 }

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/AbbreviationFeature.js

@@ -6,11 +6,11 @@ import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
 export class AbbreviationFeature {
     disposables = new Array();
     abbreviations;
-    constructor(outputChannel, selectionMoveMove) {
+    constructor(outputChannel) {
         const config = new VSCodeAbbreviationConfig();
         this.disposables.push(config);
         this.abbreviations = new AbbreviationProvider(config);
-        this.disposables.push(languages.registerHoverProvider(config.languages, new AbbreviationHoverProvider(config, this.abbreviations)), new AbbreviationRewriterFeature(config, this.abbreviations, outputChannel, selectionMoveMove));
+        this.disposables.push(languages.registerHoverProvider(config.languages, new AbbreviationHoverProvider(config, this.abbreviations)), new AbbreviationRewriterFeature(config, this.abbreviations, outputChannel));
     }
     dispose() {
         for (const d of this.disposables) {

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.d.ts

@@ -1,4 +1,4 @@
-import { AbbreviationProvider, SelectionMoveMode } from '@leanprover/unicode-input';
+import { AbbreviationProvider } from '@leanprover/unicode-input';
 import { OutputChannel } from 'vscode';
 import { VSCodeAbbreviationConfig } from './VSCodeAbbreviationConfig';
 /**
@@ -9,10 +9,9 @@ export declare class AbbreviationRewriterFeature {
     private readonly config;
     private readonly abbreviationProvider;
     private readonly outputChannel;
-    private readonly selectionMoveMove?;
     private readonly disposables;
     private activeAbbreviationRewriter;
-    constructor(config: VSCodeAbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, selectionMoveMove?: SelectionMoveMode | undefined);
+    constructor(config: VSCodeAbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel);
     private disposeActiveAbbreviationRewriter;
     private changedActiveTextEditor;
     private shouldEnableRewriterForEditor;

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/AbbreviationRewriterFeature.js

@@ -9,14 +9,12 @@ export class AbbreviationRewriterFeature {
     config;
     abbreviationProvider;
     outputChannel;
-    selectionMoveMove;
     disposables = new Array();
     activeAbbreviationRewriter;
-    constructor(config, abbreviationProvider, outputChannel, selectionMoveMove) {
+    constructor(config, abbreviationProvider, outputChannel) {
         this.config = config;
         this.abbreviationProvider = abbreviationProvider;
         this.outputChannel = outputChannel;
-        this.selectionMoveMove = selectionMoveMove;
         void this.changedActiveTextEditor(window.activeTextEditor);
         this.disposables.push(commands.registerTextEditorCommand('lean4.input.convert', async () => {
             if (this.activeAbbreviationRewriter === undefined) {
@@ -35,7 +33,7 @@ export class AbbreviationRewriterFeature {
             }
             if (this.activeAbbreviationRewriter === undefined &&
                 this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
-                this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(config, abbreviationProvider, outputChannel, window.activeTextEditor, this.selectionMoveMove);
+                this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(config, abbreviationProvider, outputChannel, window.activeTextEditor);
             }
             else if (this.activeAbbreviationRewriter !== undefined &&
                 !this.shouldEnableRewriterForEditor(window.activeTextEditor)) {
@@ -62,7 +60,7 @@ export class AbbreviationRewriterFeature {
         if (!this.shouldEnableRewriterForEditor(activeTextEditor)) {
             return;
         }
-        this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(this.config, this.abbreviationProvider, this.outputChannel, activeTextEditor, this.selectionMoveMove);
+        this.activeAbbreviationRewriter = new VSCodeAbbreviationRewriter(this.config, this.abbreviationProvider, this.outputChannel, activeTextEditor);
     }
     shouldEnableRewriterForEditor(editor) {
         if (!this.config.inputModeEnabled) {

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.d.ts

@@ -8,14 +8,13 @@ export declare class VSCodeAbbreviationRewriter implements AbbreviationTextSourc
     readonly abbreviationProvider: AbbreviationProvider;
     private readonly outputChannel;
     private readonly textEditor;
-    private selectionMoveMoveOverride?;
     private readonly disposables;
     private readonly rewriter;
     private readonly decorationType;
     private firstOutput;
     private isVimExtensionInstalled;
     private checkIsVimExtensionInstalled;
-    constructor(config: AbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, textEditor: TextEditor, selectionMoveMoveOverride?: SelectionMoveMode | undefined);
+    constructor(config: AbbreviationConfig, abbreviationProvider: AbbreviationProvider, outputChannel: OutputChannel, textEditor: TextEditor);
     private writeError;
     selectionMoveMode(): SelectionMoveMode;
     collectSelections(): Range[];

package/dist/vscode-lean4/vscode-lean4/src/abbreviation/VSCodeAbbreviationRewriter.js

@@ -8,7 +8,6 @@ export class VSCodeAbbreviationRewriter {
     abbreviationProvider;
     outputChannel;
     textEditor;
-    selectionMoveMoveOverride;
     disposables = new Array();
     rewriter;
     decorationType = window.createTextEditorDecorationType({
@@ -19,12 +18,11 @@ export class VSCodeAbbreviationRewriter {
     checkIsVimExtensionInstalled() {
         this.isVimExtensionInstalled = extensions.getExtension('vscodevim.vim') !== undefined;
     }
-    constructor(config, abbreviationProvider, outputChannel, textEditor, selectionMoveMoveOverride) {
+    constructor(config, abbreviationProvider, outputChannel, textEditor) {
         this.config = config;
         this.abbreviationProvider = abbreviationProvider;
         this.outputChannel = outputChannel;
         this.textEditor = textEditor;
-        this.selectionMoveMoveOverride = selectionMoveMoveOverride;
         this.rewriter = new AbbreviationRewriter(config, abbreviationProvider, this);
         this.disposables.push(this.decorationType);
         this.disposables.push(workspace.onDidChangeTextDocument(async (e) => {
@@ -36,7 +34,7 @@ export class VSCodeAbbreviationRewriter {
                 newText: changeEvent.text,
             }));
             this.rewriter.changeInput(changes);
-            // Wait for changes to take effect
+            // lean4monaco: We need to wait for changes to take effect. Otherwise, the cursor will be at the wrong position.
             await new Promise(resolve => setTimeout(resolve, 0));
             await this.rewriter.triggerAbbreviationReplacement();
             this.updateState();
@@ -60,10 +58,8 @@ export class VSCodeAbbreviationRewriter {
         }
     }
     selectionMoveMode() {
-        return (this.selectionMoveMoveOverride ?? {
-            kind: 'OnlyMoveCursorSelections',
-            updateUnchangedSelections: this.isVimExtensionInstalled,
-        });
+        // lean4monaco: This setting ensures that the cursor will move correctly in the browser.
+        return { kind: 'MoveAllSelections' };
     }
     collectSelections() {
         return this.textEditor.selections.map(s => fromVsCodeRange(s, this.textEditor.document));

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

@@ -1,7 +1,10 @@
+import { ThemeColor } from 'vscode';
 import { PATH } from './utils/envPath';
 export declare function getPowerShellPath(): string;
 export declare function automaticallyBuildDependencies(): boolean;
 export declare function envPathExtensions(): PATH;
+export declare function alwaysAskBeforeInstallingLeanVersions(): boolean;
+export declare function setAlwaysAskBeforeInstallingLeanVersions(alwaysAskBeforeInstallingLeanVersions: boolean): Promise<void>;
 export declare function serverArgs(): string[];
 export declare function serverLoggingEnabled(): boolean;
 export declare function serverLoggingPath(): string;
@@ -11,14 +14,24 @@ export declare function getInfoViewAutoOpen(): boolean;
 export declare function getInfoViewAutoOpenShowsGoal(): boolean;
 export declare function getInfoViewAllErrorsOnLine(): boolean;
 export declare function getInfoViewDebounceTime(): number;
-export declare function getInfoViewShowExpectedType(): boolean;
+export declare function getInfoViewExpectedTypeVisibility(): 'Expanded by default' | 'Collapsed by default' | 'Hidden';
 export declare function getInfoViewShowGoalNames(): boolean;
 export declare function getInfoViewEmphasizeFirstGoal(): boolean;
 export declare function getInfoViewReverseTacticState(): boolean;
+export declare function getInfoViewHideTypeAssumptions(): boolean;
+export declare function getInfoViewHideInstanceAssumptions(): boolean;
+export declare function getInfoViewHideInaccessibleAssumptions(): boolean;
+export declare function getInfoViewHideLetValues(): boolean;
 export declare function getInfoViewShowTooltipOnHover(): boolean;
 export declare function getElaborationDelay(): number;
 export declare function shouldShowSetupWarnings(): boolean;
 export declare function getFallBackToStringOccurrenceHighlighting(): boolean;
+export declare function showDiagnosticGutterDecorations(): boolean;
+export declare function showUnsolvedGoalsDecoration(): boolean;
+export declare function unsolvedGoalsDecorationLightThemeColor(): ThemeColor | string;
+export declare function unsolvedGoalsDecorationDarkThemeColor(): ThemeColor | string;
+export declare function goalsAccomplishedDecorationKind(): string;
+export declare function decorationEditDelay(): number;
 export declare function isRunningTest(): boolean;
 export declare function getTestFolder(): string;
 export declare function getDefaultLeanVersion(): string;

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

@@ -1,7 +1,12 @@
-import { workspace } from 'vscode';
+import { ConfigurationTarget, ThemeColor, workspace } from 'vscode';
+import { elanStableChannel } from './utils/elan';
 import { PATH } from './utils/envPath';
-// TODO: does currently not contain config options for `./abbreviation`
-// so that it is easy to keep it in sync with vscode-lean.
+function processConfigColor(c) {
+    if (c.match(/^(#|rgb\(|rgba\(|hsl\(|hsla\()/)) {
+        return c;
+    }
+    return new ThemeColor(c);
+}
 export function getPowerShellPath() {
     const windir = process.env.windir;
     return `${windir}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
@@ -12,6 +17,14 @@ export function automaticallyBuildDependencies() {
 export function envPathExtensions() {
     return new PATH(workspace.getConfiguration('lean4').get('envPathExtensions', []));
 }
+export function alwaysAskBeforeInstallingLeanVersions() {
+    return workspace.getConfiguration('lean4').get('alwaysAskBeforeInstallingLeanVersions', false);
+}
+export async function setAlwaysAskBeforeInstallingLeanVersions(alwaysAskBeforeInstallingLeanVersions) {
+    await workspace
+        .getConfiguration('lean4')
+        .update('alwaysAskBeforeInstallingLeanVersions', alwaysAskBeforeInstallingLeanVersions, ConfigurationTarget.Global);
+}
 export function serverArgs() {
     return workspace.getConfiguration('lean4').get('serverArgs', []);
 }
@@ -52,9 +65,17 @@ export function getInfoViewAllErrorsOnLine() {
 export function getInfoViewDebounceTime() {
     return workspace.getConfiguration('lean4.infoview').get('debounceTime', 50);
 }
-export function getInfoViewShowExpectedType() {
+function getInfoViewShowExpectedType() {
     return workspace.getConfiguration('lean4.infoview').get('showExpectedType', true);
 }
+export function getInfoViewExpectedTypeVisibility() {
+    const show = getInfoViewShowExpectedType();
+    const visibility = workspace.getConfiguration('lean4.infoview').get('expectedTypeVisibility', 'Expanded by default');
+    if (!show && visibility === 'Expanded by default') {
+        return 'Collapsed by default';
+    }
+    return visibility;
+}
 export function getInfoViewShowGoalNames() {
     return workspace.getConfiguration('lean4.infoview').get('showGoalNames', true);
 }
@@ -64,6 +85,18 @@ export function getInfoViewEmphasizeFirstGoal() {
 export function getInfoViewReverseTacticState() {
     return workspace.getConfiguration('lean4.infoview').get('reverseTacticState', false);
 }
+export function getInfoViewHideTypeAssumptions() {
+    return workspace.getConfiguration('lean4.infoview').get('hideTypeAssumptions', false);
+}
+export function getInfoViewHideInstanceAssumptions() {
+    return workspace.getConfiguration('lean4.infoview').get('hideInstanceAssumptions', false);
+}
+export function getInfoViewHideInaccessibleAssumptions() {
+    return workspace.getConfiguration('lean4.infoview').get('hideInaccessibleAssumptions', false);
+}
+export function getInfoViewHideLetValues() {
+    return workspace.getConfiguration('lean4.infoview').get('hideLetValues', false);
+}
 export function getInfoViewShowTooltipOnHover() {
     return workspace.getConfiguration('lean4.infoview').get('showTooltipOnHover', true);
 }
@@ -76,6 +109,24 @@ export function shouldShowSetupWarnings() {
 export function getFallBackToStringOccurrenceHighlighting() {
     return workspace.getConfiguration('lean4').get('fallBackToStringOccurrenceHighlighting', false);
 }
+export function showDiagnosticGutterDecorations() {
+    return workspace.getConfiguration('lean4').get('showDiagnosticGutterDecorations', true);
+}
+export function showUnsolvedGoalsDecoration() {
+    return workspace.getConfiguration('lean4').get('showUnsolvedGoalsDecoration', true);
+}
+export function unsolvedGoalsDecorationLightThemeColor() {
+    return processConfigColor(workspace.getConfiguration('lean4').get('unsolvedGoalsDecorationLightThemeColor', 'editorInfo.foreground'));
+}
+export function unsolvedGoalsDecorationDarkThemeColor() {
+    return processConfigColor(workspace.getConfiguration('lean4').get('unsolvedGoalsDecorationDarkThemeColor', 'editorInfo.foreground'));
+}
+export function goalsAccomplishedDecorationKind() {
+    return workspace.getConfiguration('lean4').get('goalsAccomplishedDecorationKind', 'Double Checkmark');
+}
+export function decorationEditDelay() {
+    return workspace.getConfiguration('lean4').get('decorationEditDelay', 750);
+}
 export function isRunningTest() {
     return typeof process.env.LEAN4_TEST_FOLDER === 'string';
 }
@@ -85,7 +136,7 @@ export function getTestFolder() {
 export function getDefaultLeanVersion() {
     return typeof process.env.DEFAULT_LEAN_TOOLCHAIN === 'string'
         ? process.env.DEFAULT_LEAN_TOOLCHAIN
-        : 'leanprover/lean4:stable';
+        : elanStableChannel;
 }
 /** The editor line height, in pixels. */
 export function getEditorLineHeight() {

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

@@ -1,7 +1,9 @@
 import { SemVer } from 'semver';
 import { OutputChannel } from 'vscode';
 import { ExecutionResult } from '../utils/batch';
+import { ElanDumpStateWithNetResult, ElanDumpStateWithoutNetResult } from '../utils/elan';
 import { FileUri } from '../utils/exturi';
+import { ToolchainUpdateMode } from '../utils/leanCmdRunner';
 export type SystemQueryResult = {
     operatingSystem: string;
     cpuArchitecture: string;
@@ -16,10 +18,28 @@ export type VersionQueryResult = {
 } | {
     kind: 'CommandError';
     message: string;
+} | {
+    kind: 'Cancelled';
 } | {
     kind: 'InvalidVersion';
     versionResult: string;
 };
+export type LakeAvailabilityResult = {
+    kind: 'Available';
+} | {
+    kind: 'NotAvailable';
+} | {
+    kind: 'Error';
+    message: string;
+} | {
+    kind: 'Cancelled';
+};
+export type ElanDumpStateWithoutNetQueryResult = ElanDumpStateWithoutNetResult | {
+    kind: 'PreEagerResolutionVersion';
+};
+export type ElanDumpStateWithNetQueryResult = ElanDumpStateWithNetResult | {
+    kind: 'PreEagerResolutionVersion';
+};
 export type ElanVersionDiagnosis = {
     kind: 'UpToDate';
     version: SemVer;
@@ -54,6 +74,8 @@ export type LeanVersionDiagnosis = {
     version: SemVer;
 } | {
     kind: 'NotInstalled';
+} | {
+    kind: 'Cancelled';
 } | {
     kind: 'ExecutionError';
     message: string;
@@ -69,26 +91,35 @@ export type VSCodeVersionDiagnosis = {
 export declare function versionQueryResult(executionResult: ExecutionResult, versionRegex: RegExp): VersionQueryResult;
 export declare function checkElanVersion(elanVersionResult: VersionQueryResult): ElanVersionDiagnosis;
 export declare function checkLeanVersion(leanVersionResult: VersionQueryResult): LeanVersionDiagnosis;
+export type SetupDiagnoserOptions = {
+    channel: OutputChannel | undefined;
+    cwdUri: FileUri | undefined;
+    context?: string | undefined;
+    toolchain?: string | undefined;
+    toolchainUpdateMode?: ToolchainUpdateMode | undefined;
+};
 export declare class SetupDiagnoser {
     readonly channel: OutputChannel | undefined;
     readonly cwdUri: FileUri | undefined;
+    readonly context: string | undefined;
     readonly toolchain: string | undefined;
-    constructor(channel: OutputChannel | undefined, cwdUri: FileUri | undefined, toolchain?: string | undefined);
+    readonly toolchainUpdateMode: ToolchainUpdateMode | undefined;
+    constructor(options: SetupDiagnoserOptions);
     checkCurlAvailable(): Promise<boolean>;
     checkGitAvailable(): Promise<boolean>;
-    queryLakeVersion(): Promise<VersionQueryResult>;
-    checkLakeAvailable(): Promise<boolean>;
+    checkLakeAvailable(): Promise<LakeAvailabilityResult>;
     querySystemInformation(): SystemQueryResult;
     queryExtensionVersion(): SemVer;
     queryVSCodeVersion(): VSCodeVersionDiagnosis;
     queryLeanVersion(): Promise<VersionQueryResult>;
     queryElanVersion(): Promise<VersionQueryResult>;
     queryElanShow(): Promise<ExecutionResult>;
+    queryElanStateDumpWithoutNet(): Promise<ElanDumpStateWithoutNetQueryResult>;
+    queryElanStateDumpWithNet(): Promise<ElanDumpStateWithNetQueryResult>;
     elanVersion(): Promise<ElanVersionDiagnosis>;
     projectSetup(): Promise<ProjectSetupDiagnosis>;
     leanVersion(): Promise<LeanVersionDiagnosis>;
     private runSilently;
-    private runWithProgress;
     private runLeanCommand;
 }
-export declare function diagnose(channel: OutputChannel | undefined, cwdUri: FileUri | undefined, toolchain?: string | undefined): SetupDiagnoser;
+export declare function diagnose(options: SetupDiagnoserOptions): SetupDiagnoser;

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

@@ -1,7 +1,9 @@
 import * as os from 'os';
 import { SemVer } from 'semver';
 import { extensions, version } from 'vscode';
-import { ExecutionExitCode, batchExecute, batchExecuteWithProgress } from '../utils/batch';
+import { ExecutionExitCode, batchExecute } from '../utils/batch';
+import { elanDumpStateWithNet, elanDumpStateWithoutNet, isElanEagerResolutionVersion, } from '../utils/elan';
+import { leanRunner } from '../utils/leanCmdRunner';
 import { checkParentFoldersForLeanProject, isValidLeanProject } from '../utils/projectInfo';
 const recommendedElanVersion = new SemVer('3.1.1');
 // Should be bumped in a release *before* we bump the version requirement of the VS Code extension so that
@@ -14,6 +16,9 @@ export function versionQueryResult(executionResult, versionRegex) {
     if (executionResult.exitCode === ExecutionExitCode.ExecutionError) {
         return { kind: 'CommandError', message: executionResult.combined };
     }
+    if (executionResult.exitCode === ExecutionExitCode.Cancelled) {
+        return { kind: 'Cancelled' };
+    }
     const match = versionRegex.exec(executionResult.stdout);
     if (!match) {
         return { kind: 'InvalidVersion', versionResult: executionResult.stdout };
@@ -31,6 +36,8 @@ export function checkElanVersion(elanVersionResult) {
                 kind: 'ExecutionError',
                 message: `Invalid Elan version format: '${elanVersionResult.versionResult}'`,
             };
+        case 'Cancelled':
+            throw new Error('Unexpected cancellation of `elan --version` query.');
         case 'Success':
             if (elanVersionResult.version.compare(recommendedElanVersion) < 0) {
                 return {
@@ -58,6 +65,9 @@ export function checkLeanVersion(leanVersionResult) {
             message: `Invalid Lean version format: '${leanVersionResult.versionResult}'`,
         };
     }
+    if (leanVersionResult.kind === 'Cancelled') {
+        return { kind: 'Cancelled' };
+    }
     const leanVersion = leanVersionResult.version;
     if (leanVersion.major === 3) {
         return { kind: 'IsLean3Version', version: leanVersion };
@@ -70,11 +80,15 @@ export function checkLeanVersion(leanVersionResult) {
 export class SetupDiagnoser {
     channel;
     cwdUri;
+    context;
     toolchain;
-    constructor(channel, cwdUri, toolchain) {
-        this.channel = channel;
-        this.cwdUri = cwdUri;
-        this.toolchain = toolchain;
+    toolchainUpdateMode;
+    constructor(options) {
+        this.channel = options.channel;
+        this.cwdUri = options.cwdUri;
+        this.context = options.context;
+        this.toolchain = options.toolchain;
+        this.toolchainUpdateMode = options.toolchainUpdateMode;
     }
     async checkCurlAvailable() {
         const curlVersionResult = await this.runSilently('curl', ['--version']);
@@ -84,13 +98,18 @@ export class SetupDiagnoser {
         const gitVersionResult = await this.runSilently('git', ['--version']);
         return gitVersionResult.exitCode === ExecutionExitCode.Success;
     }
-    async queryLakeVersion() {
-        const lakeVersionResult = await this.runLeanCommand('lake', ['--version'], 'Checking Lake version');
-        return versionQueryResult(lakeVersionResult, /version (\d+\.\d+\.\d+(\w|-)*)/);
-    }
     async checkLakeAvailable() {
-        const lakeVersionResult = await this.queryLakeVersion();
-        return lakeVersionResult.kind === 'Success';
+        const lakeVersionResult = await this.runLeanCommand('lake', ['--version'], 'Checking Lake version');
+        switch (lakeVersionResult.exitCode) {
+            case ExecutionExitCode.Success:
+                return { kind: 'Available' };
+            case ExecutionExitCode.CannotLaunch:
+                return { kind: 'NotAvailable' };
+            case ExecutionExitCode.ExecutionError:
+                return { kind: 'Error', message: lakeVersionResult.combined };
+            case ExecutionExitCode.Cancelled:
+                return { kind: 'Cancelled' };
+        }
     }
     querySystemInformation() {
         const cpuModels = os.cpus().map(cpu => cpu.model);
@@ -140,6 +159,26 @@ export class SetupDiagnoser {
     async queryElanShow() {
         return await this.runSilently('elan', ['show']);
     }
+    async queryElanStateDumpWithoutNet() {
+        const dumpStateResult = await elanDumpStateWithoutNet(this.cwdUri, this.toolchain);
+        if (dumpStateResult.kind === 'ExecutionError') {
+            const versionResult = await this.queryElanVersion();
+            if (versionResult.kind === 'Success' && !isElanEagerResolutionVersion(versionResult.version)) {
+                return { kind: 'PreEagerResolutionVersion' };
+            }
+        }
+        return dumpStateResult;
+    }
+    async queryElanStateDumpWithNet() {
+        const dumpStateResult = await elanDumpStateWithNet(this.cwdUri, this.toolchain);
+        if (dumpStateResult.kind === 'ExecutionError') {
+            const versionResult = await this.queryElanVersion();
+            if (versionResult.kind === 'Success' && !isElanEagerResolutionVersion(versionResult.version)) {
+                return { kind: 'PreEagerResolutionVersion' };
+            }
+        }
+        return dumpStateResult;
+    }
     async elanVersion() {
         const elanVersionResult = await this.queryElanVersion();
         return checkElanVersion(elanVersionResult);
@@ -161,20 +200,17 @@ export class SetupDiagnoser {
     async runSilently(executablePath, args) {
         return batchExecute(executablePath, args, this.cwdUri?.fsPath, { combined: this.channel });
     }
-    async runWithProgress(executablePath, args, title) {
-        return batchExecuteWithProgress(executablePath, args, title, {
-            cwd: this.cwdUri?.fsPath,
+    async runLeanCommand(executablePath, args, title) {
+        return await leanRunner.runLeanCommand(executablePath, args, {
             channel: this.channel,
+            context: this.context,
+            cwdUri: this.cwdUri,
+            waitingPrompt: title,
+            toolchain: this.toolchain,
+            toolchainUpdateMode: this.toolchainUpdateMode ?? 'UpdateAutomatically',
         });
     }
-    async runLeanCommand(executablePath, args, title) {
-        const leanArgs = [...args];
-        if (this.toolchain !== undefined) {
-            leanArgs.unshift(`+${this.toolchain}`);
-        }
-        return await this.runWithProgress(executablePath, leanArgs, title);
-    }
 }
-export function diagnose(channel, cwdUri, toolchain) {
-    return new SetupDiagnoser(channel, cwdUri, toolchain);
+export function diagnose(options) {
+    return new SetupDiagnoser(options);
 }

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

@@ -1,21 +1,26 @@
 import { OutputChannel } from 'vscode';
 import { ExtUri, FileUri } from '../utils/exturi';
+import { ToolchainUpdateMode } from '../utils/leanCmdRunner';
 import { LeanInstaller } from '../utils/leanInstaller';
-import { PreconditionCheckResult } from './setupNotifs';
+import { PreconditionCheckResult, SetupNotificationOptions } from './setupNotifs';
+export declare class SetupDiagnostics {
+    private n;
+    constructor(o: SetupNotificationOptions);
+    checkAreDependenciesInstalled(channel: OutputChannel, cwdUri: FileUri | undefined): Promise<PreconditionCheckResult>;
+    checkIsLean4Installed(installer: LeanInstaller, context: string, cwdUri: FileUri | undefined, toolchainUpdateMode: ToolchainUpdateMode): Promise<PreconditionCheckResult>;
+    checkIsElanUpToDate(installer: LeanInstaller, cwdUri: FileUri | undefined, options: {
+        elanMustBeInstalled: boolean;
+    }): Promise<PreconditionCheckResult>;
+    checkIsValidProjectFolder(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;
+    checkIsNestedProjectFolder(existingFolderUris: ExtUri[], folderUri: ExtUri, fileUri: ExtUri, stopOtherServer: (folderUri: FileUri) => Promise<void>): Promise<PreconditionCheckResult>;
+    checkIsLeanVersionUpToDate(channel: OutputChannel, context: string, folderUri: ExtUri, options: {
+        toolchainOverride?: string | undefined;
+        toolchainUpdateMode: ToolchainUpdateMode;
+    }): Promise<PreconditionCheckResult>;
+    checkIsLakeInstalledCorrectly(channel: OutputChannel, context: string, folderUri: ExtUri, options: {
+        toolchainOverride?: string | undefined;
+        toolchainUpdateMode: ToolchainUpdateMode;
+    }): Promise<PreconditionCheckResult>;
+    checkIsVSCodeUpToDate(): Promise<PreconditionCheckResult>;
+}
 export declare function checkAll(...checks: (() => Promise<PreconditionCheckResult>)[]): Promise<PreconditionCheckResult>;
-export declare function checkAreDependenciesInstalled(channel: OutputChannel, cwdUri: FileUri | undefined): Promise<PreconditionCheckResult>;
-export declare function checkIsLean4Installed(installer: LeanInstaller, cwdUri: FileUri | undefined): Promise<PreconditionCheckResult>;
-export declare function checkIsElanUpToDate(installer: LeanInstaller, cwdUri: FileUri | undefined, options: {
-    elanMustBeInstalled: boolean;
-    modal: boolean;
-}): Promise<PreconditionCheckResult>;
-export declare function checkIsValidProjectFolder(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;
-export declare function checkIsLeanVersionUpToDate(channel: OutputChannel, folderUri: ExtUri, options: {
-    toolchainOverride?: string | undefined;
-    modal: boolean;
-}): Promise<PreconditionCheckResult>;
-export declare function checkIsLakeInstalledCorrectly(channel: OutputChannel, folderUri: ExtUri, options: {
-    toolchainOverride?: string | undefined;
-}): Promise<PreconditionCheckResult>;
-export declare function checkIsVSCodeUpToDate(): Promise<PreconditionCheckResult>;
-export declare function checkLean4ProjectPreconditions(channel: OutputChannel, folderUri: ExtUri): Promise<PreconditionCheckResult>;