pub code_action_group: bool,
pub resolve_code_action: bool,
pub hover_actions: bool,
+ pub status_notification: bool,
}
impl Config {
self.client_caps.code_action_group = get_bool("codeActionGroup");
self.client_caps.resolve_code_action = get_bool("resolveCodeAction");
self.client_caps.hover_actions = get_bool("hoverActions");
+ self.client_caps.status_notification = get_bool("statusNotification");
}
}
}
pub(crate) enum Status {
Loading,
Ready,
+ Invalid,
}
impl Default for Status {
use std::{collections::HashMap, path::PathBuf};
use lsp_types::request::Request;
-use lsp_types::{Position, Range, TextDocumentIdentifier};
+use lsp_types::{notification::Notification, Position, Range, TextDocumentIdentifier};
use serde::{Deserialize, Serialize};
pub enum AnalyzerStatus {}
pub parse_only: bool,
}
+pub enum StatusNotification {}
+
+#[serde(rename_all = "camelCase")]
+#[derive(Serialize, Deserialize)]
+pub enum Status {
+ Loading,
+ Ready,
+ NeedsReload,
+ Invalid,
+}
+
+impl Notification for StatusNotification {
+ type Params = Status;
+ const METHOD: &'static str = "rust-analyzer/status";
+}
+
pub enum CodeActionRequest {}
impl Request for CodeActionRequest {
}
vfs::loader::Message::Progress { n_total, n_done } => {
if n_total == 0 {
- self.status = Status::Ready;
+ self.transition(Status::Invalid);
} else {
let state = if n_done == 0 {
- self.status = Status::Loading;
+ self.transition(Status::Loading);
Progress::Begin
} else if n_done < n_total {
Progress::Report
} else {
assert_eq!(n_done, n_total);
- self.status = Status::Ready;
+ self.transition(Status::Ready);
Progress::End
};
self.report_progress(
Ok(())
}
+ fn transition(&mut self, new_status: Status) {
+ self.status = Status::Ready;
+ if self.config.client_caps.status_notification {
+ let lsp_status = match new_status {
+ Status::Loading => lsp_ext::Status::Loading,
+ Status::Ready => lsp_ext::Status::Ready,
+ Status::Invalid => lsp_ext::Status::Invalid,
+ };
+ self.send_notification::<lsp_ext::StatusNotification>(lsp_status);
+ }
+ }
+
fn on_request(&mut self, request_received: Instant, req: Request) -> Result<()> {
self.register_request(&req, request_received);
Reloads project information (that is, re-executes `cargo metadata`).
+## Status Notification
+
+**Client Capability:** `{ "statusNotification": boolean }`
+
+**Method:** `rust-analyzer/status`
+
+**Notification:** `"loading" | "ready" | "invalid" | "needsReload"`
+
+This notification is sent from server to client.
+The client can use it to display persistent status to the user (in modline).
+For `needsReload` state, the client can provide a context-menu action to run `rust-analyzer/reloadWorkspace` request.
+
## Syntax Tree
**Method:** `rust-analyzer/syntaxTree`
caps.codeActionGroup = true;
caps.resolveCodeAction = true;
caps.hoverActions = true;
+ caps.statusNotification = true;
capabilities.experimental = caps;
}
initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {
import * as vscode from 'vscode';
import * as lc from 'vscode-languageclient';
+import * as ra from './lsp_ext';
import { Config } from './config';
import { createClient } from './client';
import { isRustEditor, RustEditor } from './util';
+import { Status } from './lsp_ext';
export class Ctx {
private constructor(
private readonly extCtx: vscode.ExtensionContext,
readonly client: lc.LanguageClient,
readonly serverPath: string,
+ readonly statusBar: vscode.StatusBarItem,
) {
}
cwd: string,
): Promise<Ctx> {
const client = createClient(serverPath, cwd);
- const res = new Ctx(config, extCtx, client, serverPath);
+
+ const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+ extCtx.subscriptions.push(statusBar);
+ statusBar.text = "rust-analyzer";
+ statusBar.tooltip = "ready";
+ statusBar.show();
+
+ const res = new Ctx(config, extCtx, client, serverPath, statusBar);
+
res.pushCleanup(client.start());
await client.onReady();
+ client.onNotification(ra.status, (status) => res.setStatus(status));
return res;
}
return this.extCtx.subscriptions;
}
+ setStatus(status: Status) {
+ switch (status) {
+ case "loading":
+ this.statusBar.text = "$(sync~spin) rust-analyzer";
+ this.statusBar.tooltip = "Loading the project";
+ this.statusBar.command = undefined;
+ this.statusBar.color = undefined;
+ break;
+ case "ready":
+ this.statusBar.text = "rust-analyzer";
+ this.statusBar.tooltip = "Ready";
+ this.statusBar.command = undefined;
+ this.statusBar.color = undefined;
+ break;
+ case "invalid":
+ this.statusBar.text = "$(error) rust-analyzer";
+ this.statusBar.tooltip = "Failed to load the project";
+ this.statusBar.command = undefined;
+ this.statusBar.color = new vscode.ThemeColor("notificationsErrorIcon.foreground");
+ break;
+ case "needsReload":
+ this.statusBar.text = "$(warning) rust-analyzer";
+ this.statusBar.tooltip = "Click to reload";
+ this.statusBar.command = "rust-analyzer.reloadWorkspace";
+ this.statusBar.color = new vscode.ThemeColor("notificationsWarningIcon.foreground");
+ break;
+ }
+ }
+
pushCleanup(d: Disposable) {
this.extCtx.subscriptions.push(d);
}
export const analyzerStatus = new lc.RequestType<null, string, void>("rust-analyzer/analyzerStatus");
+export type Status = "loading" | "ready" | "invalid" | "needsReload";
+export const status = new lc.NotificationType<Status>("rust-analyzer/status");
+
export const reloadWorkspace = new lc.RequestType<null, null, void>("rust-analyzer/reloadWorkspace");
export interface SyntaxTreeParams {