lean4monaco 1.0.45 → 1.1.0

package/dist/monaco-lean4/vscode-lean4/src/utils/converters.js

@@ -0,0 +1,129 @@
+/**
+ * For LSP communication, we need a way to translate between LSP types and corresponding VSCode types.
+ * By default this translation is provided as a bunch of methods on a `LanguageClient`, but this is
+ * awkward to use in multi-client workspaces wherein we need to look up specific clients. In fact the
+ * conversions are *not* stateful, so having them depend on the client is unnecessary. Instead, we
+ * provide global converters here.
+ *
+ * Some of the conversions are patched to support extended Lean-specific structures.
+ *
+ * @module
+ */
+import * as code from 'vscode';
+import { createConverter as createC2PConverter } from 'vscode-languageclient/lib/common/codeConverter';
+import { createConverter as createP2CConverter } from 'vscode-languageclient/lib/common/protocolConverter';
+import * as async from 'vscode-languageclient/lib/common/utils/async';
+import * as ls from 'vscode-languageserver-protocol';
+import { automaticallyBuildDependencies } from '../config';
+var SnippetTextEdit;
+(function (SnippetTextEdit) {
+    function is(value) {
+        if (!ls.TextEdit.is(value))
+            return false;
+        if (!('leanExtSnippet' in value))
+            return false;
+        const snip = value.leanExtSnippet;
+        if (snip === null || typeof snip !== 'object')
+            return false;
+        if (!('value' in snip))
+            return false;
+        if (typeof snip.value !== 'string' && !(snip.value instanceof String))
+            return false;
+        return true;
+    }
+    SnippetTextEdit.is = is;
+})(SnippetTextEdit || (SnippetTextEdit = {}));
+export function setDependencyBuildMode(params, dependencyBuildMode) {
+    const updatedParams = params;
+    updatedParams.dependencyBuildMode = automaticallyBuildDependencies() ? 'always' : dependencyBuildMode;
+    return updatedParams;
+}
+export const p2cConverter = createP2CConverter(undefined, true, true);
+export const c2pConverter = createC2PConverter(undefined);
+export function patchConverters(p2cConverter, c2pConverter) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldP2cAsDiagnostic = p2cConverter.asDiagnostic;
+    p2cConverter.asDiagnostic = function (protDiag) {
+        if (!protDiag.message) {
+            // Fixes: Notification handler 'textDocument/publishDiagnostics' failed with message: message must be set
+            protDiag.message = ' ';
+        }
+        const diag = oldP2cAsDiagnostic.apply(this, [protDiag]);
+        diag.fullRange = p2cConverter.asRange(protDiag.fullRange);
+        return diag;
+    };
+    // The original definition refers to `asDiagnostic` as a local function
+    // rather than as a member of `Protocol2CodeConverter`,
+    // so we need to overwrite it, too.
+    p2cConverter.asDiagnostics = async (diags, token) => async.map(diags, d => p2cConverter.asDiagnostic(d), token);
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldC2pAsDiagnostic = c2pConverter.asDiagnostic;
+    c2pConverter.asDiagnostic = function (diag) {
+        const protDiag = oldC2pAsDiagnostic.apply(this, [diag]);
+        protDiag.fullRange = c2pConverter.asRange(diag.fullRange);
+        return protDiag;
+    };
+    c2pConverter.asDiagnostics = async (diags, token) => async.map(diags, d => c2pConverter.asDiagnostic(d), token);
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldC2pAsOpenTextDocumentParams = c2pConverter.asOpenTextDocumentParams;
+    c2pConverter.asOpenTextDocumentParams = doc => {
+        const params = oldC2pAsOpenTextDocumentParams.apply(this, [doc]);
+        return setDependencyBuildMode(params, 'never');
+    };
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldP2CAsWorkspaceEdit = p2cConverter.asWorkspaceEdit;
+    p2cConverter.asWorkspaceEdit = async function (item, token) {
+        if (item === undefined || item === null)
+            return undefined;
+        if (item.documentChanges) {
+            // 1. Preprocess `documentChanges` by filtering out snippet edits
+            // which we support as a Lean-specific extension.
+            // 2. Create a `WorkspaceEdit` using the default function
+            // which does not take snippet edits into account.
+            // 3. Append the snippet edits.
+            // Note that this may permute the relative ordering of snippet edits and text edits,
+            // so users cannot rely on it;
+            // but a mix of both doesn't seem to work in VSCode anyway as of 1.84.2.
+            const snippetChanges = [];
+            const documentChanges = await async.map(item.documentChanges, change => {
+                if (!ls.TextDocumentEdit.is(change))
+                    return true;
+                const uri = code.Uri.parse(change.textDocument.uri);
+                const snippetEdits = [];
+                const edits = change.edits.filter(edit => {
+                    if (!SnippetTextEdit.is(edit))
+                        return true;
+                    const range = p2cConverter.asRange(edit.range);
+                    snippetEdits.push(new code.SnippetTextEdit(range, new code.SnippetString(edit.leanExtSnippet.value)));
+                    return false;
+                });
+                snippetChanges.push([uri, snippetEdits]);
+                return { ...change, edits };
+            }, token);
+            const newItem = { ...item, documentChanges };
+            const result = await oldP2CAsWorkspaceEdit.apply(this, [newItem, token]);
+            for (const [uri, snippetEdits] of snippetChanges)
+                result.set(uri, snippetEdits);
+            return result;
+        }
+        return oldP2CAsWorkspaceEdit.apply(this, [item, token]);
+    };
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const oldP2cAsCodeAction = p2cConverter.asCodeAction;
+    p2cConverter.asCodeAction = async function (item, token) {
+        if (item === undefined || item === null)
+            return undefined;
+        if (item.edit || item.diagnostics) {
+            const result = await oldP2cAsCodeAction.apply(this, [item, token]);
+            if (item.diagnostics !== undefined)
+                result.diagnostics = await p2cConverter.asDiagnostics(item.diagnostics, token);
+            if (item.edit)
+                result.edit = await p2cConverter.asWorkspaceEdit(item.edit, token);
+        }
+        return oldP2cAsCodeAction.apply(this, [item, token]);
+    };
+    // Note: as of 2023-12-10, there is no c2pConverter.asWorkspaceEdit.
+    // This is possibly because code.WorkspaceEdit supports features
+    // that cannot be encoded in ls.WorkspaceEdit.
+}
+patchConverters(p2cConverter, c2pConverter);

package/dist/monaco-lean4/vscode-lean4/src/utils/elan.d.ts

@@ -0,0 +1,3 @@
+import { OutputChannel } from 'vscode';
+import { ExecutionResult } from './batch';
+export declare function elanSelfUpdate(channel: OutputChannel): Promise<ExecutionResult>;

package/dist/monaco-lean4/vscode-lean4/src/utils/elan.js

@@ -0,0 +1,4 @@
+import { batchExecuteWithProgress } from './batch';
+export async function elanSelfUpdate(channel) {
+    return await batchExecuteWithProgress('elan', ['self', 'update'], 'Updating Elan', { channel });
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/envPath.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/** Platform independent interface to work with the PATH variable. */
+export declare class PATH {
+    paths: string[];
+    constructor(paths: string[]);
+    static empty(): PATH;
+    static ofEnvPath(envPath: string): PATH;
+    static ofEnv(env: NodeJS.ProcessEnv): PATH;
+    static ofProcessEnv(): PATH;
+    toEnvPath(): string;
+    setInEnv(env: NodeJS.ProcessEnv): void;
+    setInProcessEnv(): void;
+    prepend(path: string): PATH;
+    join(other: PATH): PATH;
+    length(): number;
+    isEmpty(): boolean;
+    includes(path: string): boolean;
+    filter(p: (path: string) => boolean): PATH;
+}
+export declare function setPATH(env: NodeJS.ProcessEnv, path: PATH): void;
+export declare function setProcessEnvPATH(path: PATH): void;

package/dist/monaco-lean4/vscode-lean4/src/utils/envPath.js

@@ -0,0 +1,53 @@
+import * as path from 'path';
+/** Platform independent interface to work with the PATH variable. */
+export class PATH {
+    paths;
+    constructor(paths) {
+        this.paths = paths;
+    }
+    static empty() {
+        return new PATH([]);
+    }
+    static ofEnvPath(envPath) {
+        return new PATH(envPath.split(path.delimiter));
+    }
+    static ofEnv(env) {
+        return PATH.ofEnvPath(env.PATH ?? '');
+    }
+    static ofProcessEnv() {
+        return PATH.ofEnv(process.env);
+    }
+    toEnvPath() {
+        return this.paths.join(path.delimiter);
+    }
+    setInEnv(env) {
+        env.PATH = this.toEnvPath();
+    }
+    setInProcessEnv() {
+        this.setInEnv(process.env);
+    }
+    prepend(path) {
+        return new PATH([path].concat(this.paths));
+    }
+    join(other) {
+        return new PATH(this.paths.concat(other.paths));
+    }
+    length() {
+        return this.paths.length;
+    }
+    isEmpty() {
+        return this.length() === 0;
+    }
+    includes(path) {
+        return this.paths.includes(path);
+    }
+    filter(p) {
+        return new PATH(this.paths.filter(p));
+    }
+}
+export function setPATH(env, path) {
+    path.setInEnv(env);
+}
+export function setProcessEnvPATH(path) {
+    setPATH(process.env, path);
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/exturi.d.ts

@@ -0,0 +1,35 @@
+import { Uri } from 'vscode';
+export declare class FileUri {
+    scheme: 'file';
+    fsPath: string;
+    constructor(fsPath: string);
+    static fromUri(uri: Uri): FileUri | undefined;
+    static fromUriOrError(uri: Uri): FileUri;
+    asUri(): Uri;
+    equals(other: FileUri): boolean;
+    equalsUri(other: Uri): boolean;
+    toString(): string;
+    join(...pathSegments: string[]): FileUri;
+    isInFolder(folderUri: FileUri): boolean;
+}
+export declare function getWorkspaceFolderUri(uri: FileUri): FileUri | undefined;
+export declare class UntitledUri {
+    scheme: 'untitled';
+    path: string;
+    constructor(path?: string | undefined);
+    static fromUri(uri: Uri): UntitledUri | undefined;
+    static fromUriOrError(uri: Uri): UntitledUri;
+    asUri(): Uri;
+    equals(other: UntitledUri): boolean;
+    equalsUri(other: Uri): boolean;
+    toString(): string;
+}
+/** Uris supported by this extension. */
+export type ExtUri = FileUri | UntitledUri;
+export declare function isExtUri(uri: Uri): boolean;
+export declare function toExtUri(uri: Uri): ExtUri | undefined;
+export declare function toExtUriOrError(uri: Uri): ExtUri;
+export declare function parseExtUri(uriString: string): ExtUri | undefined;
+export declare function parseExtUriOrError(uriString: string): ExtUri;
+export declare function extUriEquals(a: ExtUri, b: ExtUri): boolean;
+export declare function extUriToCwdUri(uri: ExtUri): FileUri | undefined;

package/dist/monaco-lean4/vscode-lean4/src/utils/exturi.js

@@ -0,0 +1,136 @@
+import { Uri, workspace } from 'vscode';
+import { isFileInFolder } from './fsHelper';
+function unsupportedSchemeError(uri) {
+    return new Error(`Got URI with unsupported scheme '${uri.scheme}': '${uri}'`);
+}
+export class FileUri {
+    scheme;
+    fsPath;
+    constructor(fsPath) {
+        this.scheme = 'file';
+        this.fsPath = fsPath;
+    }
+    static fromUri(uri) {
+        if (uri.scheme !== 'file') {
+            return undefined;
+        }
+        return new FileUri(uri.fsPath);
+    }
+    static fromUriOrError(uri) {
+        const fileUri = FileUri.fromUri(uri);
+        if (fileUri === undefined) {
+            throw unsupportedSchemeError(uri);
+        }
+        return fileUri;
+    }
+    asUri() {
+        return Uri.file(this.fsPath);
+    }
+    equals(other) {
+        return this.fsPath === other.fsPath;
+    }
+    equalsUri(other) {
+        const otherFileUri = FileUri.fromUri(other);
+        if (otherFileUri === undefined) {
+            return false;
+        }
+        return this.equals(otherFileUri);
+    }
+    toString() {
+        return this.asUri().toString();
+    }
+    join(...pathSegments) {
+        return FileUri.fromUriOrError(Uri.joinPath(this.asUri(), ...pathSegments));
+    }
+    isInFolder(folderUri) {
+        return isFileInFolder(this.fsPath, folderUri.fsPath);
+    }
+}
+export function getWorkspaceFolderUri(uri) {
+    const folder = workspace.getWorkspaceFolder(uri.asUri());
+    if (folder === undefined) {
+        return undefined;
+    }
+    const folderUri = FileUri.fromUri(folder.uri);
+    if (folderUri === undefined) {
+        return undefined;
+    }
+    return folderUri;
+}
+export class UntitledUri {
+    scheme;
+    path;
+    constructor(path) {
+        this.scheme = 'untitled';
+        this.path = path ?? '';
+    }
+    static fromUri(uri) {
+        if (uri.scheme !== 'untitled') {
+            return undefined;
+        }
+        return new UntitledUri(uri.path);
+    }
+    static fromUriOrError(uri) {
+        const untitledUri = UntitledUri.fromUri(uri);
+        if (untitledUri === undefined) {
+            throw unsupportedSchemeError(uri);
+        }
+        return untitledUri;
+    }
+    asUri() {
+        return Uri.from({ scheme: 'untitled', path: this.path });
+    }
+    equals(other) {
+        return this.path === other.path;
+    }
+    equalsUri(other) {
+        const otherFileUri = UntitledUri.fromUri(other);
+        if (otherFileUri === undefined) {
+            return false;
+        }
+        return this.equals(otherFileUri);
+    }
+    toString() {
+        return this.asUri().toString();
+    }
+}
+export function isExtUri(uri) {
+    return uri.scheme === 'untitled' || uri.scheme === 'file';
+}
+export function toExtUri(uri) {
+    if (uri.scheme === 'untitled') {
+        return new UntitledUri(uri.path);
+    }
+    if (uri.scheme === 'file') {
+        return new FileUri(uri.fsPath);
+    }
+    return undefined;
+}
+export function toExtUriOrError(uri) {
+    const result = toExtUri(uri);
+    if (result === undefined) {
+        throw unsupportedSchemeError(uri);
+    }
+    return result;
+}
+export function parseExtUri(uriString) {
+    return toExtUri(Uri.parse(uriString));
+}
+export function parseExtUriOrError(uriString) {
+    return toExtUriOrError(Uri.parse(uriString));
+}
+export function extUriEquals(a, b) {
+    if (a.scheme === 'untitled' && b.scheme === 'untitled') {
+        return a.equals(b);
+    }
+    if (a.scheme === 'file' && b.scheme === 'file') {
+        return a.equals(b);
+    }
+    return false;
+}
+export function extUriToCwdUri(uri) {
+    if (uri.scheme === 'untitled') {
+        return undefined;
+    }
+    return uri;
+}

package/dist/monaco-lean4/vscode-lean4/src/utils/fsHelper.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { PathLike } from 'fs';
+/**
+ * Returns true if `pathFile` exists and is a file
+ */
+export declare function fileExists(pathFile: PathLike): Promise<boolean>;
+/**
+ * Returns true if `pathFile` exists and is a directory
+ */
+export declare function dirExists(pathFile: PathLike): Promise<boolean>;
+/**
+ * This helper function is used to check if an specific file is in certain Folder.
+ * @param file string that contains a file name that will be checked if it exists in a certain folder.
+ * @param folder string that contains a folder name where it will check if a certain file exists
+ * @returns a boolean that says if the file exists in folder
+ */
+export declare function isFileInFolder(file: string, folder: string): boolean;

package/dist/monaco-lean4/vscode-lean4/src/utils/fsHelper.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { promises } from 'fs';
+import path from 'path';
+/**
+ * Returns true if `pathFile` exists and is a file
+ */
+export async function fileExists(pathFile) {
+    try {
+        return (await promises.stat(pathFile)).isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Returns true if `pathFile` exists and is a directory
+ */
+export async function dirExists(pathFile) {
+    try {
+        return (await promises.stat(pathFile)).isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * This helper function is used to check if an specific file is in certain Folder.
+ * @param file string that contains a file name that will be checked if it exists in a certain folder.
+ * @param folder string that contains a folder name where it will check if a certain file exists
+ * @returns a boolean that says if the file exists in folder
+ */
+export function isFileInFolder(file, folder) {
+    const relative = path.relative(folder, file);
+    const isSubdir = relative.length > 0 && !relative.startsWith('..') && !path.isAbsolute(relative);
+    return isSubdir;
+}

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

@@ -0,0 +1,37 @@
+import { SemVer } from 'semver';
+import { OutputChannel } from 'vscode';
+import { ExtUri, FileUri } from './exturi';
+import { NotificationSeverity } from './notifs';
+export declare class LeanVersion {
+    version: string;
+    error: string | undefined;
+}
+export declare class LeanInstaller {
+    private leanInstallerLinux;
+    private leanInstallerWindows;
+    private outputChannel;
+    private prompting;
+    private installing;
+    private freshInstallDefaultToolchain;
+    private elanDefaultToolchain;
+    private workspaceSuffix;
+    private defaultSuffix;
+    private promptUser;
+    private installChangedEmitter;
+    installChanged: import("vscode").Event<FileUri>;
+    constructor(outputChannel: OutputChannel, freshInstallDefaultToolchain: string);
+    getPromptUser(): boolean;
+    getOutputChannel(): OutputChannel;
+    handleVersionChanged(packageUri: FileUri): void;
+    isPromptVisible(): boolean;
+    private showRestartPromptAndRestart;
+    handleLakeFileChanged(packageUri: FileUri): void;
+    private removeSuffix;
+    getElanDefaultToolchain(packageUri: ExtUri): Promise<string>;
+    elanListToolChains(packageUri: ExtUri): Promise<string[]>;
+    hasElan(): Promise<boolean>;
+    displayInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined): Promise<boolean>;
+    displayUpdateElanPrompt(severity: NotificationSeverity, currentVersion: SemVer, recommendedVersion: SemVer): Promise<boolean>;
+    private autoInstall;
+    private installElan;
+}