feat(language_server): support multiple workspaces

Author: Sysix

crates/oxc_language_server/src/capabilities.rs

@@ -5,7 +5,7 @@ use tower_lsp_server::lsp_types::{
     WorkspaceServerCapabilities,
 };
 
-use crate::{code_actions::CODE_ACTION_KIND_SOURCE_FIX_ALL_OXC, commands::LSP_COMMANDS};
+use crate::{code_actions::CODE_ACTION_KIND_SOURCE_FIX_ALL_OXC, commands::FIX_ALL_COMMAND_ID};
 
 #[derive(Clone, Default)]
 pub struct Capabilities {
@@ -45,11 +45,6 @@ impl From<ClientCapabilities> for Capabilities {
 
 impl From<Capabilities> for ServerCapabilities {
     fn from(value: Capabilities) -> Self {
-        let commands = LSP_COMMANDS
-            .iter()
-            .filter_map(|c| if c.available(value.clone()) { Some(c.command_id()) } else { None })
-            .collect();
-
         Self {
             text_document_sync: Some(TextDocumentSyncCapability::Kind(TextDocumentSyncKind::FULL)),
             workspace: Some(WorkspaceServerCapabilities {
@@ -74,7 +69,10 @@ impl From<Capabilities> for ServerCapabilities {
                 None
             },
             execute_command_provider: if value.workspace_execute_command {
-                Some(ExecuteCommandOptions { commands, ..Default::default() })
+                Some(ExecuteCommandOptions {
+                    commands: vec![FIX_ALL_COMMAND_ID.to_string()],
+                    ..Default::default()
+                })
             } else {
                 None
             },

crates/oxc_language_server/src/commands.rs

@@ -1,118 +1,21 @@
-use std::str::FromStr;
-
-use log::error;
 use serde::Deserialize;
-use tower_lsp_server::{
-    jsonrpc::{self, Error},
-    lsp_types::{
-        ApplyWorkspaceEditParams, TextEdit, Uri, WorkspaceEdit, request::ApplyWorkspaceEdit,
-    },
-};
-
-use crate::{Backend, capabilities::Capabilities};
-
-pub const LSP_COMMANDS: [WorkspaceCommands; 1] = [WorkspaceCommands::FixAll(FixAllCommand)];
-
-pub trait WorkspaceCommand {
-    fn command_id(&self) -> String;
-    fn available(&self, cap: Capabilities) -> bool;
-    type CommandArgs<'a>: serde::Deserialize<'a>;
-    async fn execute(
-        &self,
-        backend: &Backend,
-        args: Self::CommandArgs<'_>,
-    ) -> jsonrpc::Result<Option<serde_json::Value>>;
-}
-
-pub enum WorkspaceCommands {
-    FixAll(FixAllCommand),
-}
-
-impl WorkspaceCommands {
-    pub fn command_id(&self) -> String {
-        match self {
-            WorkspaceCommands::FixAll(c) => c.command_id(),
-        }
-    }
-    pub fn available(&self, cap: Capabilities) -> bool {
-        match self {
-            WorkspaceCommands::FixAll(c) => c.available(cap),
-        }
-    }
-    pub async fn execute(
-        &self,
-        backend: &Backend,
-        args: Vec<serde_json::Value>,
-    ) -> jsonrpc::Result<Option<serde_json::Value>> {
-        match self {
-            WorkspaceCommands::FixAll(c) => {
-                let arg: Result<
-                    <FixAllCommand as WorkspaceCommand>::CommandArgs<'_>,
-                    serde_json::Error,
-                > = serde_json::from_value(serde_json::Value::Array(args));
-                if let Err(e) = arg {
-                    error!("Invalid args passed to {:?}: {e}", c.command_id());
-                    return Err(Error::invalid_request());
-                }
-                let arg = arg.unwrap();
-
-                c.execute(backend, arg).await
-            }
-        }
-    }
-}
 
-pub struct FixAllCommand;
+pub const FIX_ALL_COMMAND_ID: &str = "oxc.fixAll";
 
 #[derive(Deserialize)]
-pub struct FixAllCommandArg {
-    uri: String,
+pub struct FixAllCommandArgs {
+    pub uri: String,
 }
 
-impl WorkspaceCommand for FixAllCommand {
-    fn command_id(&self) -> String {
-        "oxc.fixAll".into()
-    }
-    fn available(&self, cap: Capabilities) -> bool {
-        cap.workspace_apply_edit
-    }
-    type CommandArgs<'a> = (FixAllCommandArg,);
-
-    async fn execute(
-        &self,
-        backend: &Backend,
-        args: Self::CommandArgs<'_>,
-    ) -> jsonrpc::Result<Option<serde_json::Value>> {
-        let url = Uri::from_str(&args.0.uri);
-        if let Err(e) = url {
-            error!("Invalid uri passed to {:?}: {e}", self.command_id());
-            return Err(Error::invalid_request());
-        }
-        let url = url.unwrap();
+impl TryFrom<Vec<serde_json::Value>> for FixAllCommandArgs {
+    type Error = &'static str;
 
-        let mut edits = vec![];
-        if let Some(value) = backend.diagnostics_report_map.pin_owned().get(&url.to_string()) {
-            for report in value {
-                if let Some(fixed) = &report.fixed_content {
-                    edits.push(TextEdit { range: fixed.range, new_text: fixed.code.clone() });
-                }
-            }
-            let _ = backend
-                .client
-                .send_request::<ApplyWorkspaceEdit>(ApplyWorkspaceEditParams {
-                    label: Some(match edits.len() {
-                        1 => "Oxlint: 1 fix applied".into(),
-                        n => format!("Oxlint: {n} fixes applied"),
-                    }),
-                    edit: WorkspaceEdit {
-                        #[expect(clippy::disallowed_types)]
-                        changes: Some(std::collections::HashMap::from([(url, edits)])),
-                        ..WorkspaceEdit::default()
-                    },
-                })
-                .await;
+    fn try_from(value: Vec<serde_json::Value>) -> Result<Self, Self::Error> {
+        if value.len() != 1 {
+            return Err("Expected exactly one argument for FixAllCommandArgs");
         }
 
-        Ok(None)
+        let first_value = value.into_iter().next().ok_or("Missing argument")?;
+        serde_json::from_value(first_value).map_err(|_| "Failed to parse FixAllCommandArgs")
     }
 }

crates/oxc_language_server/src/linter/server_linter.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use tower_lsp_server::{UriExt, lsp_types::Uri};
 
-use oxc_linter::{ConfigStoreBuilder, FixKind, LintOptions, Linter};
+use oxc_linter::Linter;
 
 use crate::linter::error_with_position::DiagnosticReport;
 use crate::linter::isolated_lint_handler::IsolatedLintHandler;
@@ -15,7 +15,10 @@ pub struct ServerLinter {
 }
 
 impl ServerLinter {
+    #[cfg(test)]
     pub fn new(options: IsolatedLintHandlerOptions) -> Self {
+        use oxc_linter::{ConfigStoreBuilder, FixKind, LintOptions};
+
         let config_store =
             ConfigStoreBuilder::default().build().expect("Failed to build config store");
         let linter = Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix);
@@ -42,7 +45,7 @@ mod test {
 
     use super::*;
     use crate::linter::tester::Tester;
-    use oxc_linter::{LintFilter, LintFilterKind, Oxlintrc};
+    use oxc_linter::{ConfigStoreBuilder, LintFilter, LintFilterKind, LintOptions, Oxlintrc};
     use rustc_hash::FxHashMap;
 
     #[test]