lean4monaco 1.0.45 → 1.1.0

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

@@ -1,17 +1,19 @@
 import { RpcErrorCode, } from '@leanprover/infoview-api';
-import { commands, env, languages, Selection, TextEditorRevealType, ViewColumn, window, workspace, } from 'vscode';
-import { getEditorLineHeight, getInfoViewAllErrorsOnLine, getInfoViewAutoOpen, getInfoViewAutoOpenShowsGoal, getInfoViewDebounceTime, getInfoViewEmphasizeFirstGoal, getInfoViewReverseTacticState, getInfoViewShowExpectedType, getInfoViewShowGoalNames, getInfoViewShowTooltipOnHover, getInfoViewStyle, } from './config';
+import { commands, ConfigurationTarget, env, Selection, TextEditorRevealType, Uri, window, workspace, } from 'vscode';
+import { getEditorLineHeight, getInfoViewAllErrorsOnLine, getInfoViewAutoOpen, getInfoViewAutoOpenShowsGoal, getInfoViewDebounceTime, getInfoViewEmphasizeFirstGoal, getInfoViewExpectedTypeVisibility, getInfoViewHideInaccessibleAssumptions, getInfoViewHideInstanceAssumptions, getInfoViewHideLetValues, getInfoViewHideTypeAssumptions, getInfoViewReverseTacticState, getInfoViewShowGoalNames, getInfoViewShowTooltipOnHover, getInfoViewStyle, minIfProd, prodOrDev, } from './config';
 import { c2pConverter, p2cConverter } from './utils/converters';
 import { parseExtUri, toExtUri } from './utils/exturi';
+import { lean } from './utils/leanEditorProvider';
 import { logger } from './utils/logger';
-import { displayError, displayInformation } from './utils/notifs';
+import { displayNotification } from './utils/notifs';
+import { viewColumnOfActiveTextEditor } from './utils/viewColumn';
 const keepAlivePeriodMs = 10000;
 async function rpcConnect(client, uri) {
     const connParams = { uri };
     const result = await client.sendRequest('$/lean/rpc/connect', connParams);
     return result.sessionId;
 }
-class RpcSessionAtPos {
+export class RpcSessionAtPos {
     sessionId;
     uri;
     keepAliveInterval;
@@ -39,8 +41,7 @@ class RpcSessionAtPos {
     }
 }
 export class InfoProvider {
-    provider;
-    leanDocs;
+    clientProvider;
     context;
     infoWebviewFactory;
     /** Instance of the panel, if it is open. Otherwise `undefined`. */
@@ -49,7 +50,6 @@ export class InfoProvider {
     clientSubscriptions = [];
     stylesheet = '';
     autoOpened = false;
-    clientProvider;
     // Subscriptions are counted and only disposed of when count becomes 0.
     serverNotifSubscriptions = new Map();
     clientNotifSubscriptions = new Map();
@@ -85,10 +85,48 @@ export class InfoProvider {
         return h;
     }
     editorApi = {
+        saveConfig: async (config) => {
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('allErrorsOnLine', config.allErrorsOnLine, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('autoOpenShowsGoal', config.autoOpenShowsGoal, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('debounceTime', config.debounceTime, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('expectedTypeVisibility', config.expectedTypeVisibility, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('showGoalNames', config.showGoalNames, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('emphasizeFirstGoal', config.emphasizeFirstGoal, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('reverseTacticState', config.reverseTacticState, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('hideTypeAssumptions', config.hideTypeAssumptions, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('hideInstanceAssumptions', config.hideInstanceAssumptions, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('hideInaccessibleAssumptions', config.hideInaccessibleAssumptions, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('hideLetValues', config.hideLetValues, ConfigurationTarget.Global);
+            await workspace
+                .getConfiguration('lean4.infoview')
+                .update('showTooltipOnHover', config.showTooltipOnHover, ConfigurationTarget.Global);
+        },
         sendClientRequest: async (uri, method, params) => {
             const extUri = parseExtUri(uri);
             if (extUri === undefined) {
-                return undefined;
+                throw Error(`Unexpected URI scheme: ${Uri.parse(uri).scheme}`);
             }
             const client = this.clientProvider.findClient(extUri);
             if (client) {
@@ -108,7 +146,7 @@ export class InfoProvider {
                     throw ex;
                 }
             }
-            return undefined;
+            throw Error('No active Lean client.');
         },
         sendClientNotification: async (uri, method, params) => {
             const extUri = parseExtUri(uri);
@@ -205,7 +243,7 @@ export class InfoProvider {
         },
         copyToClipboard: async (text) => {
             await env.clipboard.writeText(text);
-            displayInformation(`Copied to clipboard: ${text}`);
+            displayNotification('Information', `Copied to clipboard: ${text}`);
         },
         insertText: async (text, kind, tdpp) => {
             let uri;
@@ -235,29 +273,22 @@ export class InfoProvider {
             if (extUri === undefined) {
                 return;
             }
-            const client = this.clientProvider.findClient(extUri);
-            if (!client) {
-                return;
-            }
-            const document = workspace.textDocuments.find(doc => extUri.equalsUri(doc.uri));
-            if (!document || document.isClosed) {
-                return;
-            }
-            await client.restartFile(document);
+            this.clientProvider.restartFile(extUri);
         },
         createRpcSession: async (uri) => {
             const extUri = parseExtUri(uri);
             if (extUri === undefined) {
-                return '';
+                throw Error(`Unexpected URI scheme: ${Uri.parse(uri).scheme}`);
             }
             const client = this.clientProvider.findClient(extUri);
-            if (!client)
-                return '';
+            if (client === undefined) {
+                throw Error('No active Lean client.');
+            }
             const sessionId = await rpcConnect(client, uri);
             const session = new RpcSessionAtPos(client, sessionId, uri);
             if (!this.webviewPanel) {
                 session.dispose();
-                throw Error('infoview disconnect while connecting to RPC session');
+                throw Error('InfoView disconnected while connecting to RPC session.');
             }
             else {
                 this.rpcSessions.set(sessionId, session);
@@ -272,32 +303,78 @@ export class InfoProvider {
             }
         },
     };
-    constructor(provider, leanDocs, context, infoWebviewFactory) {
-        this.provider = provider;
-        this.leanDocs = leanDocs;
+    constructor(clientProvider, context, infoWebviewFactory) {
+        this.clientProvider = clientProvider;
         this.context = context;
         this.infoWebviewFactory = infoWebviewFactory;
-        this.clientProvider = provider;
         this.updateStylesheet();
-        provider.clientAdded(client => {
+        clientProvider.clientAdded(client => {
             void this.onClientAdded(client);
         });
-        provider.clientRemoved(client => {
+        clientProvider.clientRemoved(client => {
             void this.onClientRemoved(client);
         });
-        provider.clientStopped(([client, activeClient, reason]) => {
+        clientProvider.clientStopped(([client, activeClient, reason]) => {
             void this.onActiveClientStopped(client, activeClient, reason);
         });
-        this.subscriptions.push(window.onDidChangeActiveTextEditor(() => this.sendPosition()), window.onDidChangeTextEditorSelection(() => this.sendPosition()), workspace.onDidChangeConfiguration(async (_e) => {
+        this.subscriptions.push(lean.onDidChangeActiveLeanEditor(() => this.sendPosition()), lean.onDidChangeLeanEditorSelection(() => this.sendPosition()), workspace.onDidChangeConfiguration(async (_e) => {
             // regression; changing the style needs a reload. :/
             this.updateStylesheet();
             await this.sendConfig();
         }), workspace.onDidChangeTextDocument(async () => {
             await this.sendPosition();
-        }), commands.registerTextEditorCommand('lean4.displayGoal', editor => this.openPreview(editor)), commands.registerCommand('lean4.toggleInfoview', () => this.toggleInfoview()), commands.registerTextEditorCommand('lean4.displayList', async (editor) => {
-            await this.openPreview(editor);
+        }), lean.registerLeanEditorCommand('lean4.displayGoal', leanEditor => this.openPreview(leanEditor)), commands.registerCommand('lean4.toggleInfoview', () => this.toggleInfoview()), lean.registerLeanEditorCommand('lean4.displayList', async (leanEditor) => {
+            await this.openPreview(leanEditor);
             await this.webviewPanel?.api.requestedAction({ kind: 'toggleAllMessages' });
-        }), commands.registerTextEditorCommand('lean4.infoView.copyToComment', () => this.webviewPanel?.api.requestedAction({ kind: 'copyToComment' })), commands.registerCommand('lean4.infoView.toggleUpdating', () => this.webviewPanel?.api.requestedAction({ kind: 'togglePaused' })), commands.registerCommand('lean4.infoView.toggleExpectedType', () => this.webviewPanel?.api.requestedAction({ kind: 'toggleExpectedType' })), commands.registerTextEditorCommand('lean4.infoView.toggleStickyPosition', () => this.webviewPanel?.api.requestedAction({ kind: 'togglePin' })), commands.registerCommand('lean4.infoview.goToDefinition', args => this.webviewPanel?.api.goToDefinition(args.interactiveCodeTagId)));
+        }), lean.registerLeanEditorCommand('lean4.infoView.copyToComment', () => this.webviewPanel?.api.requestedAction({ kind: 'copyToComment' })), commands.registerCommand('lean4.infoView.toggleUpdating', () => this.webviewPanel?.api.requestedAction({ kind: 'togglePaused' })), commands.registerCommand('lean4.infoView.toggleExpectedType', () => this.webviewPanel?.api.requestedAction({ kind: 'toggleExpectedType' })), lean.registerLeanEditorCommand('lean4.infoView.toggleStickyPosition', () => this.webviewPanel?.api.requestedAction({ kind: 'togglePin' })), commands.registerCommand('lean4.infoview.goToDefinition', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'goToDefinition', id: args.interactiveCodeTagId })), commands.registerCommand('lean4.infoview.select', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'select', id: args.selectableLocationId })), commands.registerCommand('lean4.infoview.unselect', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'unselect', id: args.unselectableLocationId })), commands.registerCommand('lean4.infoview.unselectAll', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'unselectAll', id: args.selectedLocationsId })), commands.registerCommand('lean4.infoview.pause', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'pause', id: args.pauseId })), commands.registerCommand('lean4.infoview.unpause', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'unpause', id: args.unpauseId })), commands.registerCommand('lean4.infoview.pin', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'pin', id: args.pinId })), commands.registerCommand('lean4.infoview.unpin', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'unpin', id: args.unpinId })), commands.registerCommand('lean4.infoview.refresh', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'refresh', id: args.refreshId })), commands.registerCommand('lean4.infoview.pauseAllMessages', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'pauseAllMessages',
+            id: args.pauseAllMessagesId,
+        })), commands.registerCommand('lean4.infoview.unpauseAllMessages', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'unpauseAllMessages',
+            id: args.unpauseAllMessagesId,
+        })), commands.registerCommand('lean4.infoview.goToPinnedLocation', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'goToPinnedLocation',
+            id: args.goToPinnedLocationId,
+        })), commands.registerCommand('lean4.infoview.goToMessageLocation', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'goToMessageLocation',
+            id: args.goToMessageLocationId,
+        })), commands.registerCommand('lean4.infoview.displayTargetBeforeAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'displayTargetBeforeAssumptions',
+            id: args.displayTargetBeforeAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.displayAssumptionsBeforeTarget', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'displayAssumptionsBeforeTarget',
+            id: args.displayAssumptionsBeforeTargetId,
+        })), commands.registerCommand('lean4.infoview.hideTypeAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'hideTypeAssumptions',
+            id: args.hideTypeAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.showTypeAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'showTypeAssumptions',
+            id: args.showTypeAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.hideInstanceAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'hideInstanceAssumptions',
+            id: args.hideInstanceAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.showInstanceAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'showInstanceAssumptions',
+            id: args.showInstanceAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.hideInaccessibleAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'hideInaccessibleAssumptions',
+            id: args.hideInaccessibleAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.showInaccessibleAssumptions', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'showInaccessibleAssumptions',
+            id: args.showInaccessibleAssumptionsId,
+        })), commands.registerCommand('lean4.infoview.hideLetValues', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'hideLetValues', id: args.hideLetValuesId })), commands.registerCommand('lean4.infoview.showLetValues', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'showLetValues', id: args.showLetValuesId })), commands.registerCommand('lean4.infoview.hideGoalNames', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'hideGoalNames',
+            id: args.hideGoalNamesId,
+        })), commands.registerCommand('lean4.infoview.showGoalNames', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'showGoalNames',
+            id: args.showGoalNamesId,
+        })), commands.registerCommand('lean4.infoview.emphasizeFirstGoal', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'emphasizeFirstGoal',
+            id: args.emphasizeFirstGoalId,
+        })), commands.registerCommand('lean4.infoview.deemphasizeFirstGoal', args => this.webviewPanel?.api.clickedContextMenu({
+            entry: 'deemphasizeFirstGoal',
+            id: args.deemphasizeFirstGoalId,
+        })), commands.registerCommand('lean4.infoview.saveSettings', args => this.webviewPanel?.api.clickedContextMenu({ entry: 'saveSettings', id: args.saveSettingsId })));
     }
     async onClientRestarted(client) {
         // if we already have subscriptions for a previous client, we need to also
@@ -329,7 +406,7 @@ export class InfoProvider {
         if (this.clientsFailed.has(folderUri.toString())) {
             this.clientsFailed.delete(folderUri.toString());
         }
-        await this.initInfoView(window.activeTextEditor, client);
+        await this.initInfoView(lean.activeLeanEditor, client);
     }
     async onClientAdded(client) {
         logger.log(`[InfoProvider] Adding client for workspace: ${client.getClientFolder()}`);
@@ -441,13 +518,10 @@ export class InfoProvider {
         this.stylesheet = extraCSS + configCSS;
     }
     async autoOpen() {
-        if (!this.webviewPanel && !this.autoOpened && getInfoViewAutoOpen() && window.activeTextEditor) {
-            // only auto-open for lean files, not for markdown.
-            if (languages.match(this.leanDocs, window.activeTextEditor.document)) {
-                // remember we've auto opened during this session so if user closes it it remains closed.
-                this.autoOpened = true;
-                return await this.openPreview(window.activeTextEditor);
-            }
+        if (!this.webviewPanel && !this.autoOpened && getInfoViewAutoOpen() && lean.activeLeanEditor !== undefined) {
+            // remember we've auto opened during this session so if user closes it it remains closed.
+            this.autoOpened = true;
+            return await this.openPreview(lean.activeLeanEditor);
         }
         return false;
     }
@@ -478,40 +552,70 @@ export class InfoProvider {
             this.webviewPanel.dispose();
             // the onDispose handler sets this.webviewPanel = undefined
         }
-        else if (window.activeTextEditor && window.activeTextEditor.document.languageId === 'lean4') {
-            await this.openPreview(window.activeTextEditor);
+        else if (lean.activeLeanEditor !== undefined) {
+            await this.openPreview(lean.activeLeanEditor);
         }
         else {
-            displayError('No active Lean editor tab. Make sure to focus the Lean editor tab for which you want to open the infoview.');
+            displayNotification('Error', 'No active Lean editor tab. Make sure to focus the Lean editor tab for which you want to open the infoview.');
         }
     }
-    async openPreview(editor) {
-        const docUri = toExtUri(editor.document.uri);
-        if (docUri === undefined) {
-            return false;
-        }
-        let column = editor && editor.viewColumn ? editor.viewColumn + 1 : ViewColumn.Two;
-        if (column === 4) {
-            column = ViewColumn.Three;
-        }
+    async openPreview(leanEditor) {
         if (this.webviewPanel) {
-            this.webviewPanel.reveal(column, true);
+            this.webviewPanel.reveal(undefined, true);
         }
         else {
-            this.webviewPanel = this.infoWebviewFactory.make(this.editorApi, this.stylesheet, column);
-            this.webviewPanel.onDidDispose(() => {
+            const webviewPanel = this.infoWebviewFactory.make(this.editorApi, this.stylesheet);
+            /*
+            window.createWebviewPanel(
+                'lean4_infoview',
+                'Lean InfoView',
+                { viewColumn: viewColumnOfInfoView(), preserveFocus: true },
+                {
+                    enableFindWidget: true,
+                    retainContextWhenHidden: true,
+                    enableScripts: true,
+                    enableCommandUris: true,
+                },
+            ) as WebviewPanel & { rpc: Rpc; api: InfoviewApi }
+
+            // Note that an extension can send data to its webviews using webview.postMessage().
+            // This method sends any JSON serializable data to the webview. The message is received
+            // inside the webview through the standard message event.
+            // The receiving of these messages is done inside webview\index.ts where it
+            // calls window.addEventListener('message',...
+            webviewPanel.rpc = new Rpc(m => {
+                try {
+                    void webviewPanel.webview.postMessage(m)
+                } catch (e) {
+                    // ignore any disposed object exceptions
+                }
+            })
+            webviewPanel.rpc.register(this.editorApi)
+
+            // Similarly, we can received data from the webview by listening to onDidReceiveMessage.
+            webviewPanel.webview.onDidReceiveMessage(m => {
+                try {
+                    webviewPanel.rpc.messageReceived(m)
+                } catch {
+                    // ignore any disposed object exceptions
+                }
+            })
+            webviewPanel.api = webviewPanel.rpc.getApi()
+            */
+            webviewPanel.onDidDispose(() => {
                 this.webviewPanel = undefined;
                 this.clearNotificationHandlers();
                 this.clearRpcSessions(null); // should be after `webviewPanel = undefined`
             });
-            const client = this.clientProvider.findClient(docUri);
-            await this.initInfoView(editor, client);
+            this.webviewPanel = webviewPanel;
+            const client = this.clientProvider.findClient(leanEditor.documentExtUri);
+            await this.initInfoView(leanEditor, client);
         }
         return true;
     }
-    async initInfoView(editor, client) {
-        if (editor) {
-            const loc = this.getLocation(editor);
+    async initInfoView(leanEditor, client) {
+        if (leanEditor !== undefined) {
+            const loc = this.getLocation(leanEditor);
             if (loc) {
                 await this.webviewPanel?.api.initialize(loc);
             }
@@ -540,10 +644,14 @@ export class InfoProvider {
             allErrorsOnLine: getInfoViewAllErrorsOnLine(),
             autoOpenShowsGoal: getInfoViewAutoOpenShowsGoal(),
             debounceTime: getInfoViewDebounceTime(),
-            showExpectedType: getInfoViewShowExpectedType(),
+            expectedTypeVisibility: getInfoViewExpectedTypeVisibility(),
             showGoalNames: getInfoViewShowGoalNames(),
             emphasizeFirstGoal: getInfoViewEmphasizeFirstGoal(),
             reverseTacticState: getInfoViewReverseTacticState(),
+            hideTypeAssumptions: getInfoViewHideTypeAssumptions(),
+            hideInstanceAssumptions: getInfoViewHideInstanceAssumptions(),
+            hideInaccessibleAssumptions: getInfoViewHideInaccessibleAssumptions(),
+            hideLetValues: getInfoViewHideLetValues(),
             showTooltipOnHover: getInfoViewShowTooltipOnHover(),
         });
     }
@@ -585,13 +693,10 @@ export class InfoProvider {
         })
             .catch(() => { });
     }
-    getLocation(editor) {
-        if (!editor)
-            return undefined;
-        const uri = editor.document.uri;
-        const selection = editor.selection;
+    getLocation(leanEditor) {
+        const selection = leanEditor.editor.selection;
         return {
-            uri: uri.toString(),
+            uri: leanEditor.documentExtUri.toString(),
             range: {
                 start: selection.start,
                 end: selection.end,
@@ -599,21 +704,12 @@ export class InfoProvider {
         };
     }
     async sendPosition() {
-        const editor = window.activeTextEditor;
-        if (!editor)
-            return;
-        const loc = this.getLocation(editor);
-        if (languages.match(this.leanDocs, editor.document) === 0) {
-            // language is not yet 'lean4', but the LeanClient will fire the didSetLanguage event
-            // in openLean4Document and that's when we can send the position to update the
-            // InfoView for the newly opened document.
-            return;
-        }
-        const uri = toExtUri(editor.document.uri);
-        if (uri === undefined) {
+        const editor = lean.activeLeanEditor;
+        if (editor === undefined) {
             return;
         }
-        // actual editor
+        const loc = this.getLocation(editor);
+        const uri = editor.documentExtUri;
         if (this.clientsFailed.size > 0 || this.workersFailed.size > 0) {
             const client = this.clientProvider.findClient(uri);
             const uriKey = uri.toString();
@@ -648,16 +744,12 @@ export class InfoProvider {
         await this.webviewPanel?.api.changedCursorLocation(loc);
     }
     async revealEditorSelection(uri, selection) {
-        let editor;
-        for (const e of window.visibleTextEditors) {
-            if (uri.equalsUri(e.document.uri)) {
-                editor = e;
-                break;
-            }
-        }
-        if (!editor) {
-            const c = window.activeTextEditor ? window.activeTextEditor.viewColumn : ViewColumn.One;
-            editor = await window.showTextDocument(uri.asUri(), { viewColumn: c, preserveFocus: false });
+        let editor = lean.getVisibleLeanEditorsByUri(uri).at(0)?.editor;
+        if (editor === undefined) {
+            editor = await window.showTextDocument(uri.asUri(), {
+                viewColumn: viewColumnOfActiveTextEditor(),
+                preserveFocus: false,
+            });
         }
         if (selection !== undefined) {
             editor.revealRange(selection, TextEditorRevealType.InCenterIfOutsideViewport);
@@ -667,23 +759,17 @@ export class InfoProvider {
         }
     }
     async handleInsertText(text, kind, uri, pos) {
-        let editor;
+        let leanEditor;
         if (uri) {
-            editor = window.visibleTextEditors.find(e => uri.equalsUri(e.document.uri));
+            leanEditor = lean.getVisibleLeanEditorsByUri(uri).at(0);
         }
         else {
-            editor = window.activeTextEditor;
-            if (!editor) {
-                // sometimes activeTextEditor is null.
-                editor = window.visibleTextEditors.find(e => e.document.languageId === 'lean4');
-            }
+            leanEditor = lean.activeLeanEditor;
         }
-        if (!editor) {
-            // user must have switch away from any lean source file in which case we don't know
-            // what to do here.  TODO: show a popup error?  Or should we use the last uri used in
-            // sendPosition and automatically activate that editor?
+        if (leanEditor === undefined) {
             return;
         }
+        const editor = leanEditor.editor;
         pos = pos ? pos : editor.selection.active;
         if (kind === 'above') {
             // in this case, assume that we actually want to insert at the same
@@ -708,4 +794,33 @@ export class InfoProvider {
         // ensure the text document has the keyboard focus.
         await window.showTextDocument(editor.document, { viewColumn: editor.viewColumn, preserveFocus: false });
     }
+    getLocalPath(path) {
+        if (this.webviewPanel) {
+            // return this.webviewPanel.webview.asWebviewUri(Uri.file(join(this.context.extensionPath, path))).toString()
+        }
+        return undefined;
+    }
+    initialHtml() {
+        const libPostfix = `.${prodOrDev}${minIfProd}.js`;
+        return `
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8" />
+                <meta http-equiv="Content-type" content="text/html;charset=utf-8">
+                <title>Infoview</title>
+                <style>${this.stylesheet}</style>
+                <link rel="stylesheet" href="${this.getLocalPath('dist/lean4-infoview/index.css')}">
+            </head>
+            <body>
+                <div id="react_root"></div>
+                <script
+                    data-importmap-leanprover-infoview="${this.getLocalPath(`dist/lean4-infoview/index${libPostfix}`)}"
+                    data-importmap-react="${this.getLocalPath(`dist/lean4-infoview/react${libPostfix}`)}"
+                    data-importmap-react-jsx-runtime="${this.getLocalPath(`dist/lean4-infoview/react-jsx-runtime${libPostfix}`)}"
+                    data-importmap-react-dom="${this.getLocalPath(`dist/lean4-infoview/react-dom${libPostfix}`)}"
+                    src="${this.getLocalPath('dist/webview.js')}"></script>
+            </body>
+            </html>`;
+    }
 }

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

@@ -1,10 +1,12 @@
-import { DiagnosticCollection, Disposable, OutputChannel, TextDocument } from 'vscode';
-import { BaseLanguageClient, DidChangeTextDocumentParams, DidCloseTextDocumentParams, InitializeResult, LanguageClientOptions, PublishDiagnosticsParams } from 'vscode-languageclient/node';
+import { DiagnosticCollection, Disposable, OutputChannel } from 'vscode';
+import { BaseLanguageClient, DidChangeTextDocumentParams, DidCloseTextDocumentParams, InitializeResult, LanguageClientOptions } from 'vscode-languageclient/node';
 import { LeanFileProgressProcessingInfo, ServerStoppedReason } from '@leanprover/infoview-api';
+import { LeanPublishDiagnosticsParams } from './utils/converters';
 import { ExtUri } from './utils/exturi';
+import { LeanDocument } from './utils/leanEditorProvider';
 export type ServerProgress = Map<ExtUri, LeanFileProgressProcessingInfo[]>;
 export declare class LeanClient implements Disposable {
-    private setupClient;
+    private setupLanguageClient;
     running: boolean;
     private client;
     private outputChannel;
@@ -12,14 +14,13 @@ export declare class LeanClient implements Disposable {
     private subscriptions;
     private noPrompt;
     private showingRestartMessage;
-    private elanDefaultToolchain;
     private isRestarting;
     private staleDepNotifier;
     private openServerDocuments;
     private didChangeEmitter;
     didChange: import("vscode").Event<DidChangeTextDocumentParams>;
     private diagnosticsEmitter;
-    diagnostics: import("vscode").Event<PublishDiagnosticsParams>;
+    diagnostics: import("vscode").Event<LeanPublishDiagnosticsParams>;
     private didSetLanguageEmitter;
     didSetLanguage: import("vscode").Event<string>;
     private didCloseEmitter;
@@ -44,10 +45,11 @@ export declare class LeanClient implements Disposable {
     restartedWorker: import("vscode").Event<string>;
     private serverFailedEmitter;
     serverFailed: import("vscode").Event<string>;
-    constructor(folderUri: ExtUri, outputChannel: OutputChannel, elanDefaultToolchain: string, setupClient: (clientOptions: LanguageClientOptions, folderUri: ExtUri, elanDefaultToolchain: string) => Promise<BaseLanguageClient>);
+    constructor(folderUri: ExtUri, outputChannel: OutputChannel, setupLanguageClient: (clientOptions: LanguageClientOptions) => Promise<BaseLanguageClient>);
     dispose(): void;
     showRestartMessage(restartFile?: boolean, uri?: ExtUri | undefined): void;
     restart(): Promise<void>;
+    private determineToolchainOverride;
     private startClient;
     private checkForImportsOutdatedError;
     withStoppedClient(action: () => Promise<void>): Promise<'Success' | 'IsRestarting'>;
@@ -57,10 +59,13 @@ export declare class LeanClient implements Disposable {
     isStarted(): boolean;
     isRunning(): boolean;
     stop(): Promise<void>;
-    restartFile(doc: TextDocument): Promise<void>;
+    restartFile(leanDoc: LeanDocument): Promise<void>;
     sendRequest(method: string, params: any): Promise<any>;
     sendNotification(method: string, params: any): Promise<void> | undefined;
     getDiagnostics(): DiagnosticCollection | undefined;
     get initializeResult(): InitializeResult | undefined;
+    private determineServerOptions;
+    private determineExecutable;
     private obtainClientOptions;
+    private setupClient;
 }