chore(vscode): second language server connection for oxfmt

Author: Sysix

editors/vscode/client/ConfigService.ts

@@ -3,7 +3,7 @@ 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';
@@ -36,6 +36,13 @@ 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));
   }
@@ -84,6 +91,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,8 @@ 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;
@@ -291,7 +293,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(async (event) => {
@@ -31,32 +48,71 @@ 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);
+    await Promise.all(tools.map((tool) => tool.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.');
-    statusBarItemHandler.show();
-    outputChannel.error('No valid oxc language server binary found.');
-    return;
-  }
-
-  await linter.activate(context, binaryPath, outputChannel, configService, statusBarItemHandler);
-  // Show status bar item after activation
+
+  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 (!binaryPath && 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.');
+        } else {
+          // For the formatter we can just skip activation.
+          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);
+    }),
+  );
+
+  // 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()));
 }