Encapsulate LSP client for restart

Author: clayreimann

src/clientMain.ts

@@ -1,26 +1,22 @@
 "use strict";
 
-import * as path from "path";
 import * as fs from "fs";
 import * as tools from "./SwiftTools";
+import * as path from "path";
 import {
-  workspace,
-  window,
   commands,
-  languages,
-  ExtensionContext,
   DiagnosticCollection,
-  OutputChannel,
+  ExtensionContext,
+  languages,
   TextDocument,
+  window,
+  workspace,
 } from "vscode";
-import { LanguageClient, LanguageClientOptions, ServerOptions } from "vscode-languageclient";
-import { absolutePath } from "./AbsolutePath";
-
-import * as config from "./config-helpers";
-import output from "./output-channels";
-import { LangaugeServerMode } from "./config-helpers";
-
-import { statusBarItem } from "./status-bar";
+import { absolutePath } from "./helpers/AbsolutePath";
+import * as config from "./vscode/config-helpers";
+import lsp from "./vscode/lsp-interop";
+import output from "./vscode/output-channels";
+import { statusBarItem } from "./vscode/status-bar";
 
 let swiftBinPath: string | null = null;
 let swiftBuildParams: string[] = ["build"];
@@ -39,47 +35,17 @@ export function activate(context: ExtensionContext) {
   output.build.log("Activating SDE");
 
   initConfig();
-
-  // Options to control the language client
-  let clientOptions: LanguageClientOptions = {
-    // Register the server for plain text documents
-    documentSelector: [
-      { language: "swift", scheme: "file" },
-      { pattern: "*.swift", scheme: "file" },
-    ],
-    synchronize: {
-      configurationSection: ["swift", "editor", "[swift]"],
-      // Notify the server about file changes to '.clientrc files contain in the workspace
-      fileEvents: [
-        workspace.createFileSystemWatcher("**/*.swift"),
-        workspace.createFileSystemWatcher(".build/*.yaml"),
-      ],
-    },
-    initializationOptions: {
-      isLSPServerTracingOn: config.isLSPTracingOn(), // used by sourcekites
-      skProtocolProcess,
-      skProtocolProcessAsShellCmd,
-      skCompilerOptions: workspace.getConfiguration().get("sde.sourcekit.compilerOptions"),
-      toolchainPath:
-        workspace.getConfiguration("sourcekit-lsp").get<string>("toolchainPath") || null,
-    },
-    ...currentClientOptions(context),
-  };
-
-  // Create the language client and start the client.
-  const lspOpts = currentServerOptions(context);
-  const langClient = new LanguageClient("Swift", lspOpts, clientOptions);
-  context.subscriptions.push(langClient.start());
+  lsp.startLSPClient(context);
 
   diagnosticCollection = languages.createDiagnosticCollection("swift");
   context.subscriptions.push(diagnosticCollection);
 
   //commands
   context.subscriptions.push(
     commands.registerCommand("sde.commands.buildPackage", buildSPMPackage),
-    commands.registerCommand("sde.commands.restartLanguageServer", () => {
-      output.build.log("sde.commands.restartLanguageServer");
-    }),
+    commands.registerCommand("sde.commands.restartLanguageServer", () =>
+      lsp.restartLSPClient(context)
+    ),
     commands.registerCommand("sde.commands.runPackage", () => {
       output.build.log("sde.commands.runPackage");
     })
@@ -102,38 +68,14 @@ function initConfig() {
   checkToolsAvailability();
 
   //FIXME rootPath may be undefined for adhoc file editing mode???
-  swiftPackageManifestPath = workspace.rootPath
-    ? path.join(workspace.rootPath, "Package.swift")
+  swiftPackageManifestPath = workspace.workspaceFolders[0]
+    ? path.join(workspace.workspaceFolders[0].uri.fsPath, "Package.swift")
     : null;
 }
 
-function currentServerOptions(context: ExtensionContext): ServerOptions {
-  switch (config.lsp()) {
-    case LangaugeServerMode.LanguageServer:
-      return config.lspServerOptions(context);
-    case LangaugeServerMode.SourceKit:
-      return config.sourcekitLspServerOptions(context);
-    case LangaugeServerMode.SourceKite:
-      return config.sourcekiteServerOptions(context);
-  }
-}
-
-function currentClientOptions(_context: ExtensionContext): Partial<LanguageClientOptions> {
-  switch (config.lsp()) {
-    case LangaugeServerMode.SourceKit:
-      return {
-        documentSelector: ["swift", "cpp", "c", "objective-c", "objective-cpp"],
-        synchronize: undefined,
-      };
-    default:
-      return {};
-  }
-}
-
 function buildSPMPackage() {
   if (isSPMProject()) {
     statusBarItem.start();
-    output.build.log("Starting package build");
     tools.buildPackage(swiftBinPath, workspace.rootPath, swiftBuildParams);
   }
 }

src/SwiftTools.ts renamed to src/toolchain/SwiftTools.ts

@@ -1,10 +1,10 @@
 "use strict";
 
 import { Diagnostic, DiagnosticSeverity, Range, Uri, window as vscodeWindow } from "vscode";
-import { diagnosticCollection } from "./clientMain";
-import { isBuildTracingOn } from "./config-helpers";
-import output from "./output-channels";
-import { statusBarItem } from "./status-bar";
+import { diagnosticCollection } from "../clientMain";
+import { isBuildTracingOn } from "../vscode/config-helpers";
+import output from "../vscode/output-channels";
+import { statusBarItem } from "../vscode/status-bar";
 import cp = require("child_process");
 
 function trace(...msg: any[]) {
@@ -13,13 +13,18 @@ function trace(...msg: any[]) {
   }
 }
 
+/** parsed to generate diagnostics */
+let buildOutput = "";
+
 ///managed build now only support to invoke on save
 export function buildPackage(swiftBinPath: string, pkgPath: string, params: string[]) {
+  buildOutput = "";
   output.build.log("Build Started");
   const buildProc = cp.spawn(swiftBinPath, params, { cwd: pkgPath, shell: true });
   buildProc.stdout.on("data", data => {
     const msg = `${data}`.trim();
     if (msg.length) {
+      buildOutput += data;
       output.build.log(msg);
     }
   });
@@ -60,7 +65,7 @@ export function buildPackage(swiftBinPath: string, pkgPath: string, params: stri
 function dumpDiagnostics() {
   const diagnosticMap: Map<string, Diagnostic[]> = new Map();
   let diags: Array<string[]> = [];
-  const lines = stdout.split("\n");
+  const lines = buildOutput.split("\n");
 
   function isDiagStartLine(line: string) {
     //FIXME

src/vscode/config-helpers.ts

@@ -42,7 +42,7 @@ export function isLSPTracingOn(): boolean {
  */
 export function sourcekiteServerOptions(context: ExtensionContext): ServerOptions {
   // The server is implemented in node
-  const serverModule = context.asAbsolutePath(path.join("out/src/server", "server.js"));
+  const serverModule = context.asAbsolutePath(path.join("out/src/sourcekites-server", "server.js"));
   // The debug options for the server
   const debugOptions = {
     execArgv: ["--nolazy", "--inspect=6004"],
@@ -66,7 +66,7 @@ export function sourcekiteServerOptions(context: ExtensionContext): ServerOption
   return serverOptions;
 }
 
-export function lspServerOptions(context: ExtensionContext): ServerOptions {
+export function lspServerOptions(): ServerOptions {
   // Load the path to the language server from settings
   const executableCommand = workspace
     .getConfiguration("swift")
@@ -84,7 +84,7 @@ export function lspServerOptions(context: ExtensionContext): ServerOptions {
   return serverOptions;
 }
 
-export function sourcekitLspServerOptions(context: ExtensionContext): ServerOptions {
+export function sourcekitLspServerOptions(): ServerOptions {
   const toolchain = workspace.getConfiguration("sourcekit-lsp").get<string>("toolchainPath");
 
   const sourcekitPath = sourceKitLSPLocation(toolchain);

src/vscode/lang-client.ts

@@ -0,0 +1,82 @@
+import { workspace, ExtensionContext, Disposable } from "vscode";
+import { LanguageClient, LanguageClientOptions, ServerOptions } from "vscode-languageclient";
+import * as config from "./config-helpers";
+import { LangaugeServerMode } from "./config-helpers";
+
+function currentServerOptions(context: ExtensionContext): ServerOptions {
+  switch (config.lsp()) {
+    case LangaugeServerMode.LanguageServer:
+      return config.lspServerOptions();
+    case LangaugeServerMode.SourceKit:
+      return config.sourcekitLspServerOptions();
+    case LangaugeServerMode.SourceKite:
+      return config.sourcekiteServerOptions(context);
+  }
+}
+
+function currentClientOptions(): Partial<LanguageClientOptions> {
+  switch (config.lsp()) {
+    case LangaugeServerMode.SourceKit:
+      return {
+        documentSelector: ["swift", "cpp", "c", "objective-c", "objective-cpp"],
+        synchronize: undefined,
+      };
+    default:
+      return {};
+  }
+}
+
+let lspClient: LanguageClient | undefined;
+let clientDisposable: Disposable | undefined;
+
+/**
+ * Starts the LSP client (which specifies how to start the LSP server), and registers
+ * a dispoasble in the extension context.
+ * @param context the SDE extension context
+ */
+function startLSPClient(context: ExtensionContext) {
+  let clientOptions: LanguageClientOptions = {
+    // Register the server for plain text documentss
+    documentSelector: [
+      { language: "swift", scheme: "file" },
+      { pattern: "*.swift", scheme: "file" },
+    ],
+    synchronize: {
+      configurationSection: ["swift", "editor", "[swift]"],
+      // Notify the server about file changes to '.clientrc files contain in the workspace
+      fileEvents: [
+        workspace.createFileSystemWatcher("**/*.swift"),
+        workspace.createFileSystemWatcher(".build/*.yaml"),
+      ],
+    },
+    initializationOptions: {
+      //   isLSPServerTracingOn: config.isLSPTracingOn(), // used by sourcekite
+      //   skProtocolProcess, // used by sourcekite
+      //   skProtocolProcessAsShellCmd, // used by sourcekite
+      //   skCompilerOptions: workspace.getConfiguration().get("sde.sourcekit.compilerOptions"), // used by sourcekite
+      //   toolchainPath:
+      //     workspace.getConfiguration("sourcekit-lsp").get<string>("toolchainPath") || null,
+    },
+    ...currentClientOptions(),
+  };
+  // Create the language client and start the client.
+  const lspOpts = currentServerOptions(context);
+  lspClient = new LanguageClient("Swift", lspOpts, clientOptions);
+  clientDisposable = lspClient.start();
+  context.subscriptions.push(clientDisposable);
+}
+
+/**
+ * Stops the current LSP client and starts a new client.
+ * The client is stopped using the disposable returned from `client.start()`
+ * @param context the SDE extension context
+ */
+function restartLSPClient(context: ExtensionContext) {
+  clientDisposable.dispose();
+  startLSPClient(context);
+}
+
+export default {
+  startLSPClient,
+  restartLSPClient,
+};