refactor(language_server): introduce dummy ServerFormatter

Author: Sysix

Cargo.lock

@@ -24,7 +24,10 @@ doctest = false
 [dependencies]
 oxc_allocator = { workspace = true }
 oxc_diagnostics = { workspace = true }
+oxc_formatter = { workspace = true }
 oxc_linter = { workspace = true, features = ["language_server"] }
+oxc_parser = { workspace = true }
+oxc_span = { workspace = true }
 
 #
 env_logger = { workspace = true, features = ["humantime"] }

crates/oxc_language_server/Cargo.toml

@@ -92,6 +92,9 @@ impl From<Capabilities> for ServerCapabilities {
             } else {
                 None
             },
+            // ToDo: should by dynamic registered with workspace configuration
+            // THIS MUST NOT BE COMMITTED TO MAIN!!!
+            document_formatting_provider: Some(OneOf::Left(true)),
             ..ServerCapabilities::default()
         }
     }

crates/oxc_language_server/src/capabilities.rs

@@ -1 +1,2 @@
 pub mod options;
+pub mod server_formatter;

crates/oxc_language_server/src/formatter/mod.rs

@@ -0,0 +1,102 @@
+use std::ffi::OsStr;
+
+use oxc_allocator::Allocator;
+use oxc_formatter::{FormatOptions, Formatter};
+use oxc_parser::{ParseOptions, Parser};
+use oxc_span::SourceType;
+use tower_lsp_server::{
+    UriExt,
+    lsp_types::{Position, Range, TextEdit, Uri},
+};
+
+use crate::LSP_MAX_INT;
+
+pub struct ServerFormatter;
+
+impl ServerFormatter {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    #[expect(clippy::unused_self)]
+    pub fn run_single(&self, uri: &Uri) -> Option<Vec<TextEdit>> {
+        let path = uri.to_file_path()?;
+        let source_type = get_supported_source_type(&path)?;
+        let source_text = std::fs::read_to_string(path).expect("Failed to read file");
+
+        let allocator = Allocator::new();
+        let ret = Parser::new(&allocator, &source_text, source_type)
+            .with_options(ParseOptions {
+                parse_regular_expression: false,
+                // Enable all syntax features
+                allow_v8_intrinsics: true,
+                allow_return_outside_function: true,
+                // `oxc_formatter` expects this to be false
+                preserve_parens: false,
+            })
+            .parse();
+
+        if !ret.errors.is_empty() {
+            return None;
+        }
+
+        let options = FormatOptions {
+            // semicolons: "always".parse().unwrap(),
+            semicolons: "as-needed".parse().unwrap(),
+            ..FormatOptions::default()
+        };
+        let code = Formatter::new(&allocator, options).build(&ret.program);
+
+        Some(vec![TextEdit::new(
+            Range::new(Position::new(0, 0), Position::new(LSP_MAX_INT, 0)),
+            code,
+        )])
+    }
+}
+
+// Additional extensions from linguist-languages, which Prettier also supports
+// - https://github.com/ikatyang-collab/linguist-languages/blob/d1dc347c7ced0f5b42dd66c7d1c4274f64a3eb6b/data/JavaScript.js
+// No special extensions for TypeScript
+// - https://github.com/ikatyang-collab/linguist-languages/blob/d1dc347c7ced0f5b42dd66c7d1c4274f64a3eb6b/data/TypeScript.js
+const ADDITIONAL_JS_EXTENSIONS: &[&str] = &[
+    "_js",
+    "bones",
+    "es",
+    "es6",
+    "frag",
+    "gs",
+    "jake",
+    "javascript",
+    "jsb",
+    "jscad",
+    "jsfl",
+    "jslib",
+    "jsm",
+    "jspre",
+    "jss",
+    "njs",
+    "pac",
+    "sjs",
+    "ssjs",
+    "xsjs",
+    "xsjslib",
+];
+
+fn get_supported_source_type(path: &std::path::Path) -> Option<SourceType> {
+    let extension = path.extension()?.to_string_lossy();
+
+    // Standard extensions, also supported by `oxc_span::VALID_EXTENSIONS`
+    if let Ok(source_type) = SourceType::from_extension(&extension) {
+        return Some(source_type);
+    }
+    // Additional extensions from linguist-languages, which Prettier also supports
+    if ADDITIONAL_JS_EXTENSIONS.contains(&extension.as_ref()) {
+        return Some(SourceType::default());
+    }
+    // `Jakefile` has no extension but is a valid JS file defined by linguist-languages
+    if path.file_name() == Some(OsStr::new("Jakefile")) {
+        return Some(SourceType::default());
+    }
+
+    None
+}

crates/oxc_language_server/src/formatter/server_formatter.rs

@@ -7,9 +7,7 @@ use tower_lsp_server::lsp_types::{
 
 use oxc_diagnostics::Severity;
 
-// max range for LSP integer is 2^31 - 1
-// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#baseTypes
-const LSP_MAX_INT: u32 = 2u32.pow(31) - 1;
+use crate::LSP_MAX_INT;
 
 #[derive(Debug, Clone)]
 pub struct DiagnosticReport {

crates/oxc_language_server/src/linter/error_with_position.rs

@@ -492,7 +492,7 @@ mod test {
     fn test_lint_on_run_on_type_on_save_without_type_aware() {
         Tester::new(
             "fixtures/linter/lint_on_run/on_type",
-            Some(Options { type_aware: false, run: Run::OnType, ..Default::default() }),
+            Some(LintOptions { type_aware: false, run: Run::OnType, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-save-no-type-aware.ts", Run::OnSave);
     }

crates/oxc_language_server/src/linter/server_linter.rs

@@ -14,8 +14,8 @@ use tower_lsp_server::{
         DidChangeConfigurationParams, DidChangeTextDocumentParams, DidChangeWatchedFilesParams,
         DidChangeWatchedFilesRegistrationOptions, DidChangeWorkspaceFoldersParams,
         DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
-        ExecuteCommandParams, InitializeParams, InitializeResult, InitializedParams, Registration,
-        ServerInfo, Unregistration, Uri, WorkspaceEdit,
+        DocumentFormattingParams, ExecuteCommandParams, InitializeParams, InitializeResult,
+        InitializedParams, Registration, ServerInfo, TextEdit, Unregistration, Uri, WorkspaceEdit,
     },
 };
 
@@ -40,6 +40,10 @@ type ConcurrentHashMap<K, V> = papaya::HashMap<K, V, FxBuildHasher>;
 
 const OXC_CONFIG_FILE: &str = ".oxlintrc.json";
 
+// max range for LSP integer is 2^31 - 1
+// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#baseTypes
+const LSP_MAX_INT: u32 = 2u32.pow(31) - 1;
+
 struct Backend {
     client: Client,
     // Each Workspace has it own worker with Linter (and in the future the formatter).
@@ -562,6 +566,15 @@ impl LanguageServer for Backend {
 
         Err(Error::invalid_request())
     }
+
+    async fn formatting(&self, params: DocumentFormattingParams) -> Result<Option<Vec<TextEdit>>> {
+        let uri = &params.text_document.uri;
+        let workers = self.workspace_workers.read().await;
+        let Some(worker) = workers.iter().find(|worker| worker.is_responsible_for_uri(uri)) else {
+            return Ok(None);
+        };
+        Ok(worker.format_file(uri).await)
+    }
 }
 
 impl Backend {

crates/oxc_language_server/src/main.rs

@@ -16,6 +16,7 @@ use crate::{
         apply_all_fix_code_action, apply_fix_code_actions, ignore_this_line_code_action,
         ignore_this_rule_code_action,
     },
+    formatter::server_formatter::ServerFormatter,
     linter::{
         error_with_position::{DiagnosticReport, PossibleFixContent},
         options::LintOptions,
@@ -26,12 +27,18 @@ use crate::{
 pub struct WorkspaceWorker {
     root_uri: Uri,
     server_linter: RwLock<Option<ServerLinter>>,
+    server_formatter: RwLock<Option<ServerFormatter>>,
     options: Mutex<Options>,
 }
 
 impl WorkspaceWorker {
     pub fn new(root_uri: Uri) -> Self {
-        Self { root_uri, server_linter: RwLock::new(None), options: Mutex::new(Options::default()) }
+        Self {
+            root_uri,
+            server_linter: RwLock::new(None),
+            server_formatter: RwLock::new(None),
+            options: Mutex::new(Options::default()),
+        }
     }
 
     pub fn get_root_uri(&self) -> &Uri {
@@ -50,6 +57,11 @@ impl WorkspaceWorker {
         *self.server_linter.write().await = Some(ServerLinter::new(&self.root_uri, &options.lint));
     }
 
+    #[expect(dead_code)]
+    pub async fn init_formatter(&self) {
+        *self.server_formatter.write().await = Some(ServerFormatter::new());
+    }
+
     // WARNING: start all programs (linter, formatter) before calling this function
     // each program can tell us customized file watcher patterns
     pub async fn init_watchers(&self) -> Vec<FileSystemWatcher> {
@@ -145,6 +157,14 @@ impl WorkspaceWorker {
         server_linter.run_single(uri, content, run_type).await
     }
 
+    pub async fn format_file(&self, uri: &Uri) -> Option<Vec<TextEdit>> {
+        let Some(server_formatter) = &*self.server_formatter.read().await else {
+            return None;
+        };
+
+        server_formatter.run_single(uri)
+    }
+
     async fn revalidate_diagnostics(
         &self,
         uris: Vec<Uri>,