Refactor engine spawning internals and support global servers

Author: Xanewok

src/extension.ts

@@ -1,7 +1,3 @@
-import * as child_process from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as util from 'util';
 import {
   commands,
   ConfigurationTarget,
@@ -16,36 +12,17 @@ import {
   WorkspaceFolder,
   WorkspaceFoldersChangeEvent,
 } from 'vscode';
-import {
-  LanguageClient,
-  LanguageClientOptions,
-  NotificationType,
-  ServerOptions,
-} from 'vscode-languageclient';
+import * as lc from 'vscode-languageclient';
 
 import { RLSConfiguration } from './configuration';
-import { SignatureHelpProvider } from './providers/signatureHelpProvider';
+import * as rls from './rls';
 import * as rustAnalyzer from './rustAnalyzer';
-import { checkForRls, ensureToolchain, rustupUpdate } from './rustup';
+import { rustupUpdate } from './rustup';
 import { startSpinner, stopSpinner } from './spinner';
 import { activateTaskProvider, Execution, runRlsCommand } from './tasks';
 import { Observable } from './utils/observable';
 import { nearestParentWorkspace } from './utils/workspace';
 
-const exec = util.promisify(child_process.exec);
-
-/**
- * Parameter type to `window/progress` request as issued by the RLS.
- * https://github.com/rust-lang/rls/blob/17a439440e6b00b1f014a49c6cf47752ecae5bb7/rls/src/lsp_data.rs#L395-L419
- */
-interface ProgressParams {
-  id: string;
-  title?: string;
-  message?: string;
-  percentage?: number;
-  done?: boolean;
-}
-
 /**
  * External API as exposed by the extension. Can be queried by other extensions
  * or by the integration test runner for VSCode extensions.
@@ -187,19 +164,19 @@ function clientWorkspaceForUri(
 }
 
 /** Denotes the state or progress the workspace is currently in. */
-type WorkspaceProgress =
+export type WorkspaceProgress =
   | { state: 'progress'; message: string }
   | { state: 'ready' | 'standby' };
 
-// We run one RLS and one corresponding language client per workspace folder
-// (VSCode workspace, not Cargo workspace). This class contains all the per-client
-// and per-workspace stuff.
+// We run a single server/client pair per workspace folder (VSCode workspace,
+// not Cargo workspace). This class contains all the per-client and
+// per-workspace stuff.
 export class ClientWorkspace {
   public readonly folder: WorkspaceFolder;
   // FIXME(#233): Don't only rely on lazily initializing it once on startup,
   // handle possible `rust-client.*` value changes while extension is running
   private readonly config: RLSConfiguration;
-  private lc: LanguageClient | null = null;
+  private lc: lc.LanguageClient | null = null;
   private disposables: Disposable[];
   private _progress: Observable<WorkspaceProgress>;
   get progress() {
@@ -225,69 +202,29 @@ export class ClientWorkspace {
   public async start() {
     this._progress.value = { state: 'progress', message: 'Starting' };
 
-    const serverOptions: ServerOptions = async () => {
-      await this.autoUpdate();
-      const engine = this.config.engine;
-      return engine === 'rust-analyzer'
-        ? rustAnalyzer
-            .getServer({
-              askBeforeDownload: true,
-              package: { releaseTag: '2020-05-04' },
-            })
-            .then(binPath =>
-              child_process.execFile(binPath!),
-            ) /* TODO: Handle possibly undefined RA */
-        : this.makeRlsProcess();
-    };
-
-    // This accepts `vscode.GlobPattern` under the hood, which requires only
-    // forward slashes. It's worth mentioning that RelativePattern does *NOT*
-    // work in remote scenarios (?), so rely on normalized fs path from VSCode URIs.
-    const pattern = `${this.folder.uri.fsPath.replace(path.sep, '/')}/**`;
-
-    const clientOptions: LanguageClientOptions = {
-      // Register the server for Rust files
-      documentSelector: [
-        { language: 'rust', scheme: 'file', pattern },
-        { language: 'rust', scheme: 'untitled', pattern },
-      ],
-      diagnosticCollectionName: `rust-${this.folder.uri}`,
-      synchronize: { configurationSection: 'rust' },
-      // Controls when to focus the channel rather than when to reveal it in the drop-down list
+    const { createLanguageClient, setupClient, setupProgress } =
+      this.config.engine === 'rls' ? rls : rustAnalyzer;
+
+    const client = await createLanguageClient(this.folder, {
+      updateOnStartup: this.config.updateOnStartup,
       revealOutputChannelOn: this.config.revealOutputChannelOn,
-      initializationOptions: {
-        omitInitBuild: true,
-        cmdRun: true,
+      logToFile: this.config.logToFile,
+      rustup: {
+        channel: this.config.channel,
+        path: this.config.rustupPath,
+        disabled: this.config.rustupDisabled,
       },
-      workspaceFolder: this.folder,
-    };
-
-    // Create the language client and start the client.
-    this.lc = new LanguageClient(
-      'rust-client',
-      'Rust Language Server',
-      serverOptions,
-      clientOptions,
-    );
-
-    if (this.config.engine === 'rust-analyzer') {
-      // Register for semantic tokens, among others
-      this.lc.registerProposedFeatures();
-    }
+      rls: { path: this.config.rlsPath },
+      rustAnalyzer: { releaseTag: '2020-05-04' },
+    });
 
-    const selector = { language: 'rust', scheme: 'file', pattern };
+    setupProgress(client, this._progress);
 
-    this.setupProgressCounter();
     this.disposables.push(activateTaskProvider(this.folder));
-    this.disposables.push(this.lc.start());
-    this.disposables.push(
-      languages.registerSignatureHelpProvider(
-        selector,
-        new SignatureHelpProvider(this.lc),
-        '(',
-        ',',
-      ),
-    );
+    this.disposables.push(...setupClient(client, this.folder));
+    if (client.needsStart()) {
+      this.disposables.push(client.start());
+    }
   }
 
   public async stop() {
@@ -312,154 +249,6 @@ export class ClientWorkspace {
   public rustupUpdate() {
     return rustupUpdate(this.config.rustupConfig());
   }
-
-  private async setupProgressCounter() {
-    if (!this.lc) {
-      return;
-    }
-
-    const runningProgress: Set<string> = new Set();
-    await this.lc.onReady();
-
-    this.lc.onNotification(
-      new NotificationType<ProgressParams, void>('window/progress'),
-      progress => {
-        if (progress.done) {
-          runningProgress.delete(progress.id);
-        } else {
-          runningProgress.add(progress.id);
-        }
-        if (runningProgress.size) {
-          let status = '';
-          if (typeof progress.percentage === 'number') {
-            status = `${Math.round(progress.percentage * 100)}%`;
-          } else if (progress.message) {
-            status = progress.message;
-          } else if (progress.title) {
-            status = `[${progress.title.toLowerCase()}]`;
-          }
-          this._progress.value = { state: 'progress', message: status };
-        } else {
-          this._progress.value = { state: 'ready' };
-        }
-      },
-    );
-  }
-
-  private async getSysroot(env: typeof process.env): Promise<string> {
-    const printSysrootCmd = this.config.rustupDisabled
-      ? 'rustc --print sysroot'
-      : `${this.config.rustupPath} run ${this.config.channel} rustc --print sysroot`;
-
-    const { stdout } = await exec(printSysrootCmd, { env });
-    return stdout.toString().trim();
-  }
-
-  // Make an evironment to run the RLS.
-  private async makeRlsEnv(
-    args = {
-      setLibPath: false,
-    },
-  ): Promise<typeof process.env> {
-    // Shallow clone, we don't want to modify this process' $PATH or
-    // $(DY)LD_LIBRARY_PATH
-    const env = { ...process.env };
-
-    let sysroot: string | undefined;
-    try {
-      sysroot = await this.getSysroot(env);
-    } catch (err) {
-      console.info(err.message);
-      console.info(`Let's retry with extended $PATH`);
-      env.PATH = `${env.HOME || '~'}/.cargo/bin:${env.PATH || ''}`;
-      try {
-        sysroot = await this.getSysroot(env);
-      } catch (e) {
-        console.warn('Error reading sysroot (second try)', e);
-        window.showWarningMessage(`Error reading sysroot: ${e.message}`);
-        return env;
-      }
-    }
-
-    console.info(`Setting sysroot to`, sysroot);
-    if (args.setLibPath) {
-      function appendEnv(envVar: string, newComponent: string) {
-        const old = process.env[envVar];
-        return old ? `${newComponent}:${old}` : newComponent;
-      }
-      const newComponent = path.join(sysroot, 'lib');
-      env.DYLD_LIBRARY_PATH = appendEnv('DYLD_LIBRARY_PATH', newComponent);
-      env.LD_LIBRARY_PATH = appendEnv('LD_LIBRARY_PATH', newComponent);
-    }
-
-    return env;
-  }
-
-  private async makeRlsProcess(): Promise<child_process.ChildProcess> {
-    // Run "rls" from the PATH unless there's an override.
-    const rlsPath = this.config.rlsPath || 'rls';
-
-    // We don't need to set [DY]LD_LIBRARY_PATH if we're using rustup,
-    // as rustup will set it for us when it chooses a toolchain.
-    // NOTE: Needs an installed toolchain when using rustup, hence we don't call
-    // it immediately here.
-    const makeRlsEnv = () =>
-      this.makeRlsEnv({
-        setLibPath: this.config.rustupDisabled,
-      });
-    const cwd = this.folder.uri.fsPath;
-
-    let childProcess: child_process.ChildProcess;
-    if (this.config.rustupDisabled) {
-      console.info(`running without rustup: ${rlsPath}`);
-      const env = await makeRlsEnv();
-
-      childProcess = child_process.spawn(rlsPath, [], {
-        env,
-        cwd,
-        shell: true,
-      });
-    } else {
-      console.info(`running with rustup: ${rlsPath}`);
-      const config = this.config.rustupConfig();
-
-      await ensureToolchain(config);
-      if (!this.config.rlsPath) {
-        // We only need a rustup-installed RLS if we weren't given a
-        // custom RLS path.
-        console.info('will use a rustup-installed RLS; ensuring present');
-        await checkForRls(config);
-      }
-
-      const env = await makeRlsEnv();
-      childProcess = child_process.spawn(
-        config.path,
-        ['run', config.channel, rlsPath],
-        { env, cwd, shell: true },
-      );
-    }
-
-    childProcess.on('error', (err: { code?: string; message: string }) => {
-      if (err.code === 'ENOENT') {
-        console.error(`Could not spawn RLS: ${err.message}`);
-        window.showWarningMessage(`Could not spawn RLS: \`${err.message}\``);
-      }
-    });
-
-    if (this.config.logToFile) {
-      const logPath = path.join(this.folder.uri.fsPath, `rls${Date.now()}.log`);
-      const logStream = fs.createWriteStream(logPath, { flags: 'w+' });
-      childProcess.stderr?.pipe(logStream);
-    }
-
-    return childProcess;
-  }
-
-  private async autoUpdate() {
-    if (this.config.updateOnStartup && !this.config.rustupDisabled) {
-      await rustupUpdate(this.config.rustupConfig());
-    }
-  }
 }
 
 /**