WIP

Author: vinistock

vscode/src/sorbet.ts

@@ -0,0 +1,40 @@
+import * as vscode from "vscode";
+import {
+  LanguageClient,
+  ServerOptions,
+  LanguageClientOptions,
+  RevealOutputChannelOn,
+} from "vscode-languageclient/node";
+
+import { WorkspaceChannel } from "./workspaceChannel";
+import { Ruby } from "./ruby";
+
+export default class SorbetClient extends LanguageClient {
+  constructor(
+    ruby: Ruby,
+    workspaceFolder: vscode.WorkspaceFolder,
+    outputChannel: WorkspaceChannel,
+  ) {
+    const serverOptions: ServerOptions = {
+      command: "bundle",
+      args: ["exec", "srb", "tc", "--lsp"],
+      options: {
+        cwd: workspaceFolder.uri.fsPath,
+        env: ruby.env,
+        shell: true,
+      },
+    };
+
+    const clientOptions: LanguageClientOptions = {
+      documentSelector: [
+        { language: "ruby", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
+      ],
+      workspaceFolder,
+      diagnosticCollectionName: "sorbet",
+      outputChannel,
+      revealOutputChannelOn: RevealOutputChannelOn.Never,
+    };
+
+    super("sorbet", serverOptions, clientOptions);
+  }
+}

vscode/src/workspace.ts

@@ -11,6 +11,7 @@ import {
   debounce,
 } from "./common";
 import { WorkspaceChannel } from "./workspaceChannel";
+import SorbetClient from "./sorbet";
 
 export class Workspace implements WorkspaceInterface {
   public lspClient?: Client;
@@ -22,6 +23,7 @@ export class Workspace implements WorkspaceInterface {
   private readonly isMainWorkspace: boolean;
   private readonly telemetry: vscode.TelemetryLogger;
   private needsRestart = false;
+  private sorbetClient?: SorbetClient;
   #rebaseInProgress = false;
   #error = false;
 
@@ -96,6 +98,10 @@ export class Workspace implements WorkspaceInterface {
       await this.lspClient.stop();
       await this.lspClient.dispose();
     }
+    if (this.sorbetClient) {
+      await this.sorbetClient.stop();
+      await this.sorbetClient.dispose();
+    }
 
     this.lspClient = new Client(
       this.context,
@@ -106,11 +112,17 @@ export class Workspace implements WorkspaceInterface {
       this.outputChannel,
       this.isMainWorkspace,
     );
+    this.sorbetClient = new SorbetClient(
+      this.ruby,
+      this.workspaceFolder,
+      this.outputChannel,
+    );
 
     try {
       STATUS_EMITTER.fire(this);
       await this.lspClient.start();
       await this.lspClient.afterStart();
+      await this.sorbetClient.start();
       STATUS_EMITTER.fire(this);
 
       // If something triggered a restart while we were still booting, then now we need to perform the restart since the
@@ -127,6 +139,7 @@ export class Workspace implements WorkspaceInterface {
 
   async stop() {
     await this.lspClient?.stop();
+    await this.sorbetClient?.stop();
   }
 
   async restart() {
@@ -138,39 +151,50 @@ export class Workspace implements WorkspaceInterface {
       this.error = false;
 
       // If there's no client, then we can just start a new one
-      if (!this.lspClient) {
-        return this.start();
-      }
-
-      switch (this.lspClient.state) {
-        // If the server is still starting, then it may not be ready to handle a shutdown request yet. Trying to send
-        // one could lead to a hanging process. Instead we set a flag and only restart once the server finished booting
-        // in `start`
-        case State.Starting:
-          this.needsRestart = true;
-          break;
-        // If the server is running, we want to stop it, dispose of the client and start a new one
-        case State.Running:
-          await this.stop();
-          await this.lspClient.dispose();
-          this.lspClient = undefined;
-          await this.start();
-          break;
-        // If the server is already stopped, then we need to dispose it and start a new one
-        case State.Stopped:
-          await this.lspClient.dispose();
-          this.lspClient = undefined;
-          await this.start();
-          break;
+      if (this.lspClient && this.sorbetClient) {
+        try {
+          await this.sorbetClient.stop();
+          await this.sorbetClient.dispose();
+        } catch (error: any) {
+          this.outputChannel.error(
+            `Error restarting the Sorbet server: ${error.message}`,
+          );
+        }
+        this.sorbetClient = undefined;
+
+        switch (this.lspClient.state) {
+          // If the server is still starting, then it may not be ready to handle a shutdown request yet. Trying to send
+          // one could lead to a hanging process. Instead we set a flag and only restart once the server finished
+          // booting in `start`
+          case State.Starting:
+            this.needsRestart = true;
+            break;
+          // If the server is running, we want to stop it, dispose of the client and start a new one
+          case State.Running:
+            await this.stop();
+            await this.lspClient.dispose();
+            this.lspClient = undefined;
+            await this.start();
+            break;
+          // If the server is already stopped, then we need to dispose it and start a new one
+          case State.Stopped:
+            await this.lspClient.dispose();
+            this.lspClient = undefined;
+            await this.start();
+            break;
+        }
       }
     } catch (error: any) {
       this.error = true;
       this.outputChannel.error(`Error restarting the server: ${error.message}`);
     }
+
+    return this.start();
   }
 
   async dispose() {
     await this.lspClient?.dispose();
+    await this.sorbetClient?.dispose();
   }
 
   // Install or update the `ruby-lsp` gem globally with `gem install ruby-lsp` or `gem update ruby-lsp`. We only try to