More robust status notifications

[rust.git] / editors / code / src / ctx.ts

diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index c06d8ac31760982be0bf6c0542341d7215ffdc40..c05e757f864f54e406cde3a1740402fd3dd32f08 100644 (file)
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -1,52 +1,56 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient';
-import { strict as assert } from "assert";
+import * as lc from 'vscode-languageclient/node';
+import * as ra from './lsp_ext';
 
 import { Config } from './config';
 import { createClient } from './client';
+import { isRustEditor, RustEditor } from './util';
+import { ServerStatusParams } from './lsp_ext';
 
 export class Ctx {
-    readonly config: Config;
-    // Because we have "reload server" action, various listeners **will** face a
-    // situation where the client is not ready yet, and should be prepared to
-    // deal with it.
-    //
-    // Ideally, this should be replaced with async getter though.
-    // FIXME: this actually needs syncronization of some kind (check how
-    // vscode deals with `deactivate()` call when extension has some work scheduled
-    // on the event loop to get a better picture of what we can do here)
-    client: lc.LanguageClient | null = null;
-    private extCtx: vscode.ExtensionContext;
+    private constructor(
+        readonly config: Config,
+        private readonly extCtx: vscode.ExtensionContext,
+        readonly client: lc.LanguageClient,
+        readonly serverPath: string,
+        readonly statusBar: vscode.StatusBarItem,
+    ) {
 
-    constructor(extCtx: vscode.ExtensionContext) {
-        this.config = new Config(extCtx);
-        this.extCtx = extCtx;
     }
 
-    async startServer() {
-        assert(this.client == null);
+    static async create(
+        config: Config,
+        extCtx: vscode.ExtensionContext,
+        serverPath: string,
+        cwd: string,
+    ): Promise<Ctx> {
+        const client = createClient(serverPath, cwd, config.serverExtraEnv);
 
-        const client = await createClient(this.config);
-        if (!client) {
-            throw new Error(
-                "Rust Analyzer Language Server is not available. " +
-                "Please, ensure its [proper installation](https://github.com/rust-analyzer/rust-analyzer/tree/master/docs/user#vs-code)."
-            );
-        }
+        const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+        extCtx.subscriptions.push(statusBar);
+        statusBar.text = "rust-analyzer";
+        statusBar.tooltip = "ready";
+        statusBar.show();
 
-        this.pushCleanup(client.start());
-        await client.onReady();
+        const res = new Ctx(config, extCtx, client, serverPath, statusBar);
 
-        this.client = client;
+        res.pushCleanup(client.start());
+        await client.onReady();
+        client.onNotification(ra.serverStatus, (params) => res.setServerStatus(params));
+        return res;
     }
 
-    get activeRustEditor(): vscode.TextEditor | undefined {
+    get activeRustEditor(): RustEditor | undefined {
         const editor = vscode.window.activeTextEditor;
-        return editor && editor.document.languageId === 'rust'
+        return editor && isRustEditor(editor)
             ? editor
             : undefined;
     }
 
+    get visibleRustEditors(): RustEditor[] {
+        return vscode.window.visibleTextEditors.filter(isRustEditor);
+    }
+
     registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
         const fullName = `rust-analyzer.${name}`;
         const cmd = factory(this);
@@ -62,6 +66,30 @@ export class Ctx {
         return this.extCtx.subscriptions;
     }
 
+    setServerStatus(status: ServerStatusParams) {
+        this.statusBar.tooltip = status.message ?? "Ready";
+        let icon = "";
+        switch (status.health) {
+            case "ok":
+                this.statusBar.color = undefined;
+                break;
+            case "warning":
+                this.statusBar.tooltip += "\nClick to reload."
+                this.statusBar.command = "rust-analyzer.reloadWorkspace";
+                this.statusBar.color = new vscode.ThemeColor("notificationsWarningIcon.foreground");
+                icon = "$(warning) ";
+                break;
+            case "error":
+                this.statusBar.tooltip += "\nClick to reload."
+                this.statusBar.command = "rust-analyzer.reloadWorkspace";
+                this.statusBar.color = new vscode.ThemeColor("notificationsErrorIcon.foreground");
+                icon = "$(error) ";
+                break;
+        }
+        if (!status.quiescent) icon = "$(sync~spin) ";
+        this.statusBar.text = `${icon} rust-analyzer`;
+    }
+
     pushCleanup(d: Disposable) {
         this.extCtx.subscriptions.push(d);
     }
@@ -71,24 +99,3 @@ export interface Disposable {
     dispose(): void;
 }
 export type Cmd = (...args: any[]) => unknown;
-
-export async function sendRequestWithRetry<R>(
-    client: lc.LanguageClient,
-    method: string,
-    param: unknown,
-    token?: vscode.CancellationToken,
-): Promise<R> {
-    for (const delay of [2, 4, 6, 8, 10, null]) {
-        try {
-            return await (token ? client.sendRequest(method, param, token) : client.sendRequest(method, param));
-        } catch (err) {
-            if (delay === null || err.code !== lc.ErrorCodes.ContentModified) {
-                throw err;
-            }
-            await sleep(10 * (1 << delay));
-        }
-    }
-    throw 'unreachable';
-}
-
-const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));