Weave in global state when constructing lang server

Author: Xanewok

src/extension.ts

@@ -11,6 +11,7 @@ import {
   workspace,
   WorkspaceFolder,
   WorkspaceFoldersChangeEvent,
+  Memento,
 } from 'vscode';
 import * as lc from 'vscode-languageclient';
 
@@ -32,17 +33,21 @@ export interface Api {
 }
 
 export async function activate(context: ExtensionContext): Promise<Api> {
+  // Weave in global state when handling changed active text editor
+  const handleChangedActiveTextEd = (ed: TextEditor | undefined) =>
+    onDidChangeActiveTextEditor(ed, context.globalState);
+
   context.subscriptions.push(
     ...[
       configureLanguage(),
       ...registerCommands(),
       workspace.onDidChangeWorkspaceFolders(whenChangingWorkspaceFolders),
-      window.onDidChangeActiveTextEditor(onDidChangeActiveTextEditor),
+      window.onDidChangeActiveTextEditor(handleChangedActiveTextEd),
     ],
   );
   // Manually trigger the first event to start up server instance if necessary,
   // since VSCode doesn't do that on startup by itself.
-  onDidChangeActiveTextEditor(window.activeTextEditor);
+  handleChangedActiveTextEd(window.activeTextEditor);
 
   // Migrate the users of multi-project setup for RLS to disable the setting
   // entirely (it's always on now)
@@ -81,13 +86,16 @@ export async function deactivate() {
 /** Tracks dynamically updated progress for the active client workspace for UI purposes. */
 let progressObserver: Disposable | undefined;
 
-function onDidChangeActiveTextEditor(editor: TextEditor | undefined) {
+function onDidChangeActiveTextEditor(
+  editor: TextEditor | undefined,
+  globalState: Memento,
+) {
   if (!editor || !editor.document) {
     return;
   }
   const { languageId, uri } = editor.document;
 
-  const workspace = clientWorkspaceForUri(uri, {
+  const workspace = clientWorkspaceForUri(uri, globalState, {
     initializeIfMissing: languageId === 'rust' || languageId === 'toml',
   });
   if (!workspace) {
@@ -135,6 +143,7 @@ const workspaces: Map<string, ClientWorkspace> = new Map();
  */
 function clientWorkspaceForUri(
   uri: Uri,
+  globalState: Memento,
   options?: { initializeIfMissing: boolean },
 ): ClientWorkspace | undefined {
   const rootFolder = workspace.getWorkspaceFolder(uri);
@@ -149,7 +158,7 @@ function clientWorkspaceForUri(
 
   const existing = workspaces.get(folder.uri.toString());
   if (!existing && options && options.initializeIfMissing) {
-    const workspace = new ClientWorkspace(folder);
+    const workspace = new ClientWorkspace(folder, globalState);
     workspaces.set(folder.uri.toString(), workspace);
     workspace.autoStart();
   }
@@ -173,15 +182,17 @@ export class ClientWorkspace {
   private lc: lc.LanguageClient | null = null;
   private disposables: Disposable[];
   private _progress: Observable<WorkspaceProgress>;
+  private globalState: Memento;
   get progress() {
     return this._progress;
   }
 
-  constructor(folder: WorkspaceFolder) {
+  constructor(folder: WorkspaceFolder, globalState: Memento) {
     this.config = RLSConfiguration.loadFromWorkspace(folder.uri.fsPath);
     this.folder = folder;
     this.disposables = [];
     this._progress = new Observable<WorkspaceProgress>({ state: 'standby' });
+    this.globalState = globalState;
   }
 
   /**
@@ -198,18 +209,22 @@ export class ClientWorkspace {
     const { createLanguageClient, setupClient, setupProgress } =
       this.config.engine === 'rls' ? rls : rustAnalyzer;
 
-    const client = await createLanguageClient(this.folder, {
-      updateOnStartup: this.config.updateOnStartup,
-      revealOutputChannelOn: this.config.revealOutputChannelOn,
-      logToFile: this.config.logToFile,
-      rustup: {
-        channel: this.config.channel,
-        path: this.config.rustupPath,
-        disabled: this.config.rustupDisabled,
+    const client = await createLanguageClient(
+      this.folder,
+      {
+        updateOnStartup: this.config.updateOnStartup,
+        revealOutputChannelOn: this.config.revealOutputChannelOn,
+        logToFile: this.config.logToFile,
+        rustup: {
+          channel: this.config.channel,
+          path: this.config.rustupPath,
+          disabled: this.config.rustupDisabled,
+        },
+        rls: { path: this.config.rlsPath },
+        rustAnalyzer: this.config.rustAnalyzer,
       },
-      rls: { path: this.config.rlsPath },
-      rustAnalyzer: this.config.rustAnalyzer,
-    });
+      this.globalState,
+    );
 
     client.onDidChangeState(({ newState }) => {
       if (newState === lc.State.Starting) {

src/rust-analyzer/persistent_state.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { promisify } from 'util';
+import * as vscode from 'vscode';
 
 const stat = promisify(fs.stat);
 const mkdir = promisify(fs.mkdir);
@@ -32,22 +33,20 @@ export interface Metadata {
   releaseTag: string;
 }
 
-export async function readMetadata(): Promise<
-  Metadata | Record<string, unknown>
-> {
+export async function readMetadata(): Promise<Partial<Metadata>> {
   const stateDir = metadataDir();
   if (!stateDir) {
-    return { kind: 'error', code: 'NotSupported' };
+    throw new Error('Not supported');
   }
 
   const filePath = path.join(stateDir, 'metadata.json');
   if (!(await stat(filePath).catch(() => false))) {
-    return { kind: 'error', code: 'FileMissing' };
+    throw new Error('File missing');
   }
 
   const contents = await readFile(filePath, 'utf8');
   const obj = JSON.parse(contents) as unknown;
-  return typeof obj === 'object' ? (obj as Record<string, unknown>) : {};
+  return typeof obj === 'object' ? obj || {} : {};
 }
 
 export async function writeMetadata(config: Metadata) {
@@ -67,3 +66,42 @@ export async function writeMetadata(config: Metadata) {
 function ensureDir(path: string) {
   return !!path && stat(path).catch(() => mkdir(path, { recursive: true }));
 }
+
+export class PersistentState {
+  constructor(private readonly globalState: vscode.Memento) {
+    const { lastCheck, releaseId, serverVersion } = this;
+    console.info('PersistentState:', { lastCheck, releaseId, serverVersion });
+  }
+
+  /**
+   * Used to check for *nightly* updates once an hour.
+   */
+  get lastCheck(): number | undefined {
+    return this.globalState.get('lastCheck');
+  }
+  async updateLastCheck(value: number) {
+    await this.globalState.update('lastCheck', value);
+  }
+
+  /**
+   * Release id of the *nightly* extension.
+   * Used to check if we should update.
+   */
+  get releaseId(): number | undefined {
+    return this.globalState.get('releaseId');
+  }
+  async updateReleaseId(value: number) {
+    await this.globalState.update('releaseId', value);
+  }
+
+  /**
+   * Version of the extension that installed the server.
+   * Used to check if we need to update the server.
+   */
+  get serverVersion(): string | undefined {
+    return this.globalState.get('serverVersion');
+  }
+  async updateServerVersion(value: string | undefined) {
+    await this.globalState.update('serverVersion', value);
+  }
+}

src/rust-analyzer/rustAnalyzer.ts

@@ -10,7 +10,12 @@ import { WorkspaceProgress } from '../extension';
 import { download, fetchRelease } from '../net';
 import * as rustup from '../rustup';
 import { Observable } from '../utils/observable';
-import { Metadata, readMetadata, writeMetadata } from './persistent_state';
+import {
+  Metadata,
+  readMetadata,
+  writeMetadata,
+  PersistentState,
+} from './persistent_state';
 
 const stat = promisify(fs.stat);
 const mkdir = promisify(fs.mkdir);
@@ -55,10 +60,12 @@ interface RustAnalyzerConfig {
   };
 }
 
-export async function getServer({
-  askBeforeDownload,
-  package: pkg,
-}: RustAnalyzerConfig): Promise<string | undefined> {
+export async function getServer(
+  config: RustAnalyzerConfig,
+  state: PersistentState,
+): Promise<string | undefined> {
+  const { askBeforeDownload, package: pkg } = config;
+
   let binaryName: string | undefined;
   if (process.arch === 'x64' || process.arch === 'ia32') {
     if (process.platform === 'linux') {
@@ -159,17 +166,21 @@ export async function createLanguageClient(
     rustup: { disabled: boolean; path: string; channel: string };
     rustAnalyzer: { path?: string; releaseTag: string };
   },
+  state: vs.Memento,
 ): Promise<lc.LanguageClient> {
   if (!config.rustup.disabled) {
     await rustup.ensureToolchain(config.rustup);
     await rustup.ensureComponents(config.rustup, REQUIRED_COMPONENTS);
   }
 
   if (!config.rustAnalyzer.path) {
-    await getServer({
-      askBeforeDownload: true,
-      package: { releaseTag: config.rustAnalyzer.releaseTag },
-    });
+    await getServer(
+      {
+        askBeforeDownload: true,
+        package: { releaseTag: config.rustAnalyzer.releaseTag },
+      },
+      new PersistentState(state),
+    );
   }
 
   if (INSTANCE) {
@@ -179,9 +190,12 @@ export async function createLanguageClient(
   const serverOptions: lc.ServerOptions = async () => {
     const binPath =
       config.rustAnalyzer.path ||
-      (await getServer({
-        package: { releaseTag: config.rustAnalyzer.releaseTag },
-      }));
+      (await getServer(
+        {
+          package: { releaseTag: config.rustAnalyzer.releaseTag },
+        },
+        new PersistentState(state),
+      ));
 
     if (!binPath) {
       throw new Error("Couldn't fetch Rust Analyzer binary");