chore(vscode): second language server connection for oxfmt

Author: Sysix

editors/vscode/client/ConfigService.ts

@@ -3,7 +3,11 @@ import { ConfigurationChangeEvent, Uri, workspace, WorkspaceFolder } from "vscod
 import { validateSafeBinaryPath } from "./PathValidator";
 import { IDisposable } from "./types";
 import { VSCodeConfig } from "./VSCodeConfig";
-import { WorkspaceConfig, WorkspaceConfigInterface } from "./WorkspaceConfig";
+import {
+  OxfmtWorkspaceConfigInterface,
+  WorkspaceConfig,
+  WorkspaceConfigInterface,
+} from "./WorkspaceConfig";
 
 export class ConfigService implements IDisposable {
   public static readonly namespace = "oxc";
@@ -40,6 +44,16 @@ export class ConfigService implements IDisposable {
     }));
   }
 
+  public get formatterServerConfig(): {
+    workspaceUri: string;
+    options: OxfmtWorkspaceConfigInterface;
+  }[] {
+    return [...this.workspaceConfigs.entries()].map(([path, config]) => ({
+      workspaceUri: Uri.file(path).toString(),
+      options: config.toOxfmtConfig(),
+    }));
+  }
+
   public addWorkspaceConfig(workspace: WorkspaceFolder): void {
     this.workspaceConfigs.set(workspace.uri.path, new WorkspaceConfig(workspace));
   }
@@ -88,6 +102,12 @@ export class ConfigService implements IDisposable {
     return bin;
   }
 
+  public async getOxfmtServerBinPath(): Promise<string | undefined> {
+    const files = await workspace.findFiles("**/node_modules/.bin/oxfmt", null, 1);
+
+    return files.length > 0 ? files[0].fsPath : undefined;
+  }
+
   private async onVscodeConfigChange(event: ConfigurationChangeEvent): Promise<void> {
     let isConfigChanged = false;
 

editors/vscode/client/StatusBarItemHandler.ts

@@ -34,7 +34,7 @@ export default class StatusBarItemHandler {
   }
 
   private updateFullTooltip(): void {
-    const text = Array.from(this.tooltipSections.values()).join("\n\n");
+    const text = Array.from(this.tooltipSections.values()).join("\n\n---\n\n");
 
     if (!(this.statusBarItem.tooltip instanceof MarkdownString)) {
       this.statusBarItem.tooltip = new MarkdownString("", true);

editors/vscode/client/VSCodeConfig.ts

@@ -5,6 +5,7 @@ export class VSCodeConfig implements VSCodeConfigInterface {
   private _enable!: boolean;
   private _trace!: TraceLevel;
   private _binPathOxlint: string | undefined;
+  private _binPathOxfmt: string | undefined;
   private _nodePath: string | undefined;
   private _requireConfig!: boolean;
 
@@ -25,6 +26,7 @@ export class VSCodeConfig implements VSCodeConfigInterface {
     this._enable = this.configuration.get<boolean>("enable") ?? true;
     this._trace = this.configuration.get<TraceLevel>("trace.server") || "off";
     this._binPathOxlint = binPathOxlint;
+    this._binPathOxfmt = this.configuration.get<string>("path.oxfmt");
     this._nodePath = this.configuration.get<string>("path.node");
     this._requireConfig = this.configuration.get<boolean>("requireConfig") ?? false;
   }
@@ -56,6 +58,15 @@ export class VSCodeConfig implements VSCodeConfigInterface {
     return this.configuration.update("path.oxlint", value);
   }
 
+  get binPathOxfmt(): string | undefined {
+    return this._binPathOxfmt;
+  }
+
+  updateBinPathOxfmt(value: string | undefined): PromiseLike<void> {
+    this._binPathOxfmt = value;
+    return this.configuration.update("path.oxfmt", value);
+  }
+
   get nodePath(): string | undefined {
     return this._nodePath;
   }

editors/vscode/client/WorkspaceConfig.ts

@@ -100,6 +100,11 @@ export interface WorkspaceConfigInterface {
   ["fmt.configPath"]?: string | null;
 }
 
+export type OxfmtWorkspaceConfigInterface = Pick<
+  WorkspaceConfigInterface,
+  "fmt.experimental" | "fmt.configPath"
+>;
+
 export class WorkspaceConfig {
   private _configPath: string | null = null;
   private _tsConfigPath: string | null = null;
@@ -314,7 +319,7 @@ export class WorkspaceConfig {
     };
   }
 
-  public toOxfmtConfig(): Pick<WorkspaceConfigInterface, "fmt.experimental" | "fmt.configPath"> {
+  public toOxfmtConfig(): OxfmtWorkspaceConfigInterface {
     return {
       ["fmt.experimental"]: this.formattingExperimental,
       ["fmt.configPath"]: this.formattingConfigPath ?? null,

editors/vscode/client/commands.ts

@@ -1,9 +1,15 @@
 const commandPrefix = "oxc";
 
 export const enum OxcCommands {
-  ShowOutputChannel = `${commandPrefix}.showOutputChannel`,
+  // always available, even if no tool is active
+  ShowOutputChannelLint = `${commandPrefix}.showOutputChannel`,
+  ShowOutputChannelFmt = `${commandPrefix}.showOutputChannelFormatter`,
+
   // only for linter.ts usage
-  RestartServer = `${commandPrefix}.restartServer`,
-  ToggleEnable = `${commandPrefix}.toggleEnable`,
+  RestartServerLint = `${commandPrefix}.restartServer`, // without `Linter` suffix for backward compatibility
+  ToggleEnableLint = `${commandPrefix}.toggleEnable`, // without `Linter` suffix for backward compatibility
   ApplyAllFixesFile = `${commandPrefix}.applyAllFixesFile`,
+
+  // only for formatter.ts usage
+  RestartServerFmt = `${commandPrefix}.restartServerFormatter`,
 }

editors/vscode/client/extension.ts

@@ -3,20 +3,37 @@ import { commands, ExtensionContext, window, workspace } from "vscode";
 import { OxcCommands } from "./commands";
 import { ConfigService } from "./ConfigService";
 import StatusBarItemHandler from "./StatusBarItemHandler";
+import Formatter from "./tools/formatter";
 import Linter from "./tools/linter";
+import ToolInterface from "./tools/ToolInterface";
 
 const outputChannelName = "Oxc";
-const linter = new Linter();
+const tools: ToolInterface[] = [];
+
+if (process.env.SKIP_LINTER_TEST !== "true") {
+  tools.push(new Linter());
+}
+if (process.env.SKIP_FORMATTER_TEST !== "true") {
+  tools.push(new Formatter());
+}
 
 export async function activate(context: ExtensionContext) {
   const configService = new ConfigService();
 
-  const outputChannel = window.createOutputChannel(outputChannelName, {
+  const outputChannelLint = window.createOutputChannel(outputChannelName + " (Lint)", {
+    log: true,
+  });
+
+  const outputChannelFormat = window.createOutputChannel(outputChannelName + " (Fmt)", {
     log: true,
   });
 
-  const showOutputCommand = commands.registerCommand(OxcCommands.ShowOutputChannel, () => {
-    outputChannel.show();
+  const showOutputLintCommand = commands.registerCommand(OxcCommands.ShowOutputChannelLint, () => {
+    outputChannelLint.show();
+  });
+
+  const showOutputFmtCommand = commands.registerCommand(OxcCommands.ShowOutputChannelFmt, () => {
+    outputChannelFormat.show();
   });
 
   const onDidChangeWorkspaceFoldersDispose = workspace.onDidChangeWorkspaceFolders(
@@ -33,35 +50,87 @@ export async function activate(context: ExtensionContext) {
   const statusBarItemHandler = new StatusBarItemHandler(context.extension.packageJSON?.version);
 
   context.subscriptions.push(
-    showOutputCommand,
+    showOutputLintCommand,
+    showOutputFmtCommand,
     configService,
-    outputChannel,
+    outputChannelLint,
+    outputChannelFormat,
     onDidChangeWorkspaceFoldersDispose,
     statusBarItemHandler,
   );
 
   configService.onConfigChange = async function onConfigChange(event) {
-    await linter.onConfigChange(event, configService, statusBarItemHandler);
-  };
-  const binaryPath = await linter.getBinary(context, outputChannel, configService);
-
-  // For the linter this should never happen, but just in case.
-  if (!binaryPath) {
-    statusBarItemHandler.setColorAndIcon("statusBarItem.errorBackground", "error");
-    statusBarItemHandler.updateToolTooltip(
-      "linter",
-      "Error: No valid oxc language server binary found.",
+    await Promise.all(
+      tools.map((tool) => tool.onConfigChange(event, configService, statusBarItemHandler)),
     );
-    statusBarItemHandler.show();
-    outputChannel.error("No valid oxc language server binary found.");
-    return;
-  }
+  };
+
+  const foundBinaries: string[] = [];
+
+  await Promise.all(
+    tools.map(async (tool) => {
+      const outputChannel = tool instanceof Linter ? outputChannelLint : outputChannelFormat;
+      const binaryPath = await tool.getBinary(context, outputChannel, configService);
+
+      // For the linter this should never happen, but just in case.
+      if (!binaryPath && tool instanceof Linter) {
+        statusBarItemHandler.setColorAndIcon("statusBarItem.errorBackground", "error");
+        statusBarItemHandler.updateToolTooltip(
+          "linter",
+          "Error: No valid oxc language server binary found.",
+        );
+      }
+
+      if (tool instanceof Formatter) {
+        if (foundBinaries.some((path) => path.includes("oxc_language_server"))) {
+          // The formatter is already handled by the linter tool in this case.
+          statusBarItemHandler.updateToolTooltip(
+            "formatter",
+            "oxc_language_server is used for formatting.",
+          );
+          outputChannelFormat.appendLine("oxc_language_server is used for formatting.");
+          return;
+        } else if (!binaryPath) {
+          // No valid binary found for the formatter.
+          statusBarItemHandler.updateToolTooltip(
+            "formatter",
+            "No valid oxfmt binary found. Formatter will not be activated.",
+          );
+          outputChannelFormat.appendLine(
+            "No valid oxfmt binary found. Formatter will not be activated.",
+          );
+          return;
+        }
+      }
+
+      // binaryPath is guaranteed to be defined here.
+      const binaryPathResolved = binaryPath!;
+
+      // do not activate the same binary multiple times.
+      // This only happens when the `oxc_language_server` is used, which support both linting and formatting.
+      //
+      // The `linter` tool is prioritized here, so the formatter will not be activated if the linter already uses the same binary.
+      // Because the linter source code also handles formatting in that case. (for now)
+      if (foundBinaries.includes(binaryPathResolved)) {
+        return;
+      }
+
+      foundBinaries.push(binaryPathResolved);
+
+      return tool.activate(
+        context,
+        binaryPathResolved,
+        outputChannel,
+        configService,
+        statusBarItemHandler,
+      );
+    }),
+  );
 
-  await linter.activate(context, binaryPath, outputChannel, configService, statusBarItemHandler);
-  // Show status bar item after activation
+  // Finally show the status bar item.
   statusBarItemHandler.show();
 }
 
 export async function deactivate(): Promise<void> {
-  await linter.deactivate();
+  await Promise.all(tools.map((tool) => tool.deactivate()));
 }