Merge pull request #2507 from Philipp-M/multiple-language-servers

Add support for multiple language servers per language

9 files changed, 747 insertions, 713 deletions

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index b54d6835..40c6d8c6 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -30,6 +30,7 @@ use crate::{
 
 use log::{debug, error, warn};
 use std::{
+    collections::btree_map::Entry,
     io::{stdin, stdout},
     path::Path,
     sync::Arc,
@@ -564,7 +565,7 @@ impl Application {
             let doc = doc_mut!(self.editor, &doc_save_event.doc_id);
             let id = doc.id();
             doc.detect_language(loader);
-            let _ = self.editor.refresh_language_server(id);
+            self.editor.refresh_language_servers(id);
         }
 
         // TODO: fix being overwritten by lsp
@@ -662,6 +663,18 @@ impl Application {
     ) {
         use helix_lsp::{Call, MethodCall, Notification};
 
+        macro_rules! language_server {
+            () => {
+                match self.editor.language_server_by_id(server_id) {
+                    Some(language_server) => language_server,
+                    None => {
+                        warn!("can't find language server with id `{}`", server_id);
+                        return;
+                    }
+                }
+            };
+        }
+
         match call {
             Call::Notification(helix_lsp::jsonrpc::Notification { method, params, .. }) => {
                 let notification = match Notification::parse(&method, params) {
@@ -677,14 +690,7 @@ impl Application {
 
                 match notification {
                     Notification::Initialized => {
-                        let language_server =
-                            match self.editor.language_servers.get_by_id(server_id) {
-                                Some(language_server) => language_server,
-                                None => {
-                                    warn!("can't find language server with id `{}`", server_id);
-                                    return;
-                                }
-                            };
+                        let language_server = language_server!();
 
                         // Trigger a workspace/didChangeConfiguration notification after initialization.
                         // This might not be required by the spec but Neovim does this as well, so it's
@@ -693,9 +699,10 @@ impl Application {
                             tokio::spawn(language_server.did_change_configuration(config.clone()));
                         }
 
-                        let docs = self.editor.documents().filter(|doc| {
-                            doc.language_server().map(|server| server.id()) == Some(server_id)
-                        });
+                        let docs = self
+                            .editor
+                            .documents()
+                            .filter(|doc| doc.supports_language_server(server_id));
 
                         // trigger textDocument/didOpen for docs that are already open
                         for doc in docs {
@@ -715,7 +722,7 @@ impl Application {
                             ));
                         }
                     }
-                    Notification::PublishDiagnostics(mut params) => {
+                    Notification::PublishDiagnostics(params) => {
                         let path = match params.uri.to_file_path() {
                             Ok(path) => path,
                             Err(_) => {
@@ -723,6 +730,7 @@ impl Application {
                                 return;
                             }
                         };
+                        let offset_encoding = language_server!().offset_encoding();
                         let doc = self.editor.document_by_path_mut(&path).filter(|doc| {
                             if let Some(version) = params.version {
                                 if version != doc.version() {
@@ -745,18 +753,11 @@ impl Application {
                                     use helix_core::diagnostic::{Diagnostic, Range, Severity::*};
                                     use lsp::DiagnosticSeverity;
 
-                                    let language_server = if let Some(language_server) = doc.language_server() {
-                                        language_server
-                                    } else {
-                                        log::warn!("Discarding diagnostic because language server is not initialized: {:?}", diagnostic);
-                                        return None;
-                                    };
-
                                     // TODO: convert inside server
                                     let start = if let Some(start) = lsp_pos_to_pos(
                                         text,
                                         diagnostic.range.start,
-                                        language_server.offset_encoding(),
+                                        offset_encoding,
                                     ) {
                                         start
                                     } else {
@@ -764,11 +765,9 @@ impl Application {
                                         return None;
                                     };
 
-                                    let end = if let Some(end) = lsp_pos_to_pos(
-                                        text,
-                                        diagnostic.range.end,
-                                        language_server.offset_encoding(),
-                                    ) {
+                                    let end = if let Some(end) =
+                                        lsp_pos_to_pos(text, diagnostic.range.end, offset_encoding)
+                                    {
                                         end
                                     } else {
                                         log::warn!("lsp position out of bounds - {:?}", diagnostic);
@@ -807,14 +806,19 @@ impl Application {
                                         None => None,
                                     };
 
-                                    let tags = if let Some(ref tags) = diagnostic.tags {
-                                        let new_tags = tags.iter().filter_map(|tag| {
-                                            match *tag {
-                                                lsp::DiagnosticTag::DEPRECATED => Some(DiagnosticTag::Deprecated),
-                                                lsp::DiagnosticTag::UNNECESSARY => Some(DiagnosticTag::Unnecessary),
-                                                _ => None
-                                            }
-                                        }).collect();
+                                    let tags = if let Some(tags) = &diagnostic.tags {
+                                        let new_tags = tags
+                                            .iter()
+                                            .filter_map(|tag| match *tag {
+                                                lsp::DiagnosticTag::DEPRECATED => {
+                                                    Some(DiagnosticTag::Deprecated)
+                                                }
+                                                lsp::DiagnosticTag::UNNECESSARY => {
+                                                    Some(DiagnosticTag::Unnecessary)
+                                                }
+                                                _ => None,
+                                            })
+                                            .collect();
 
                                         new_tags
                                     } else {
@@ -830,25 +834,40 @@ impl Application {
                                         tags,
                                         source: diagnostic.source.clone(),
                                         data: diagnostic.data.clone(),
+                                        language_server_id: server_id,
                                     })
                                 })
                                 .collect();
 
-                            doc.set_diagnostics(diagnostics);
+                            doc.replace_diagnostics(diagnostics, server_id);
                         }
 
-                        // Sort diagnostics first by severity and then by line numbers.
-                        // Note: The `lsp::DiagnosticSeverity` enum is already defined in decreasing order
-                        params
+                        let mut diagnostics = params
                             .diagnostics
-                            .sort_unstable_by_key(|d| (d.severity, d.range.start));
+                            .into_iter()
+                            .map(|d| (d, server_id))
+                            .collect();
 
                         // Insert the original lsp::Diagnostics here because we may have no open document
                         // for diagnosic message and so we can't calculate the exact position.
                         // When using them later in the diagnostics picker, we calculate them on-demand.
-                        self.editor
-                            .diagnostics
-                            .insert(params.uri, params.diagnostics);
+                        match self.editor.diagnostics.entry(params.uri) {
+                            Entry::Occupied(o) => {
+                                let current_diagnostics = o.into_mut();
+                                // there may entries of other language servers, which is why we can't overwrite the whole entry
+                                current_diagnostics.retain(|(_, lsp_id)| *lsp_id != server_id);
+                                current_diagnostics.append(&mut diagnostics);
+                                // Sort diagnostics first by severity and then by line numbers.
+                                // Note: The `lsp::DiagnosticSeverity` enum is already defined in decreasing order
+                                current_diagnostics
+                                    .sort_unstable_by_key(|(d, _)| (d.severity, d.range.start));
+                            }
+                            Entry::Vacant(v) => {
+                                diagnostics
+                                    .sort_unstable_by_key(|(d, _)| (d.severity, d.range.start));
+                                v.insert(diagnostics);
+                            }
+                        };
                     }
                     Notification::ShowMessage(params) => {
                         log::warn!("unhandled window/showMessage: {:?}", params);
@@ -950,10 +969,8 @@ impl Application {
                             .editor
                             .documents_mut()
                             .filter_map(|doc| {
-                                if doc.language_server().map(|server| server.id())
-                                    == Some(server_id)
-                                {
-                                    doc.set_diagnostics(Vec::new());
+                                if doc.supports_language_server(server_id) {
+                                    doc.clear_diagnostics(server_id);
                                     doc.url()
                                 } else {
                                     None
@@ -1029,31 +1046,21 @@ impl Application {
                         }))
                     }
                     Ok(MethodCall::WorkspaceFolders) => {
-                        let language_server =
-                            self.editor.language_servers.get_by_id(server_id).unwrap();
-
-                        Ok(json!(&*language_server.workspace_folders().await))
+                        Ok(json!(&*language_server!().workspace_folders().await))
                     }
                     Ok(MethodCall::WorkspaceConfiguration(params)) => {
+                        let language_server = language_server!();
                         let result: Vec<_> = params
                             .items
                             .iter()
                             .map(|item| {
-                                let mut config = match &item.scope_uri {
-                                    Some(scope) => {
-                                        let path = scope.to_file_path().ok()?;
-                                        let doc = self.editor.document_by_path(path)?;
-                                        doc.language_config()?.config.as_ref()?
-                                    }
-                                    None => self
-                                        .editor
-                                        .language_servers
-                                        .get_by_id(server_id)?
-                                        .config()?,
-                                };
+                                let mut config = language_server.config()?;
                                 if let Some(section) = item.section.as_ref() {
-                                    for part in section.split('.') {
-                                        config = config.get(part)?;
+                                    // for some reason some lsps send an empty string (observed in 'vscode-eslint-language-server')
+                                    if !section.is_empty() {
+                                        for part in section.split('.') {
+                                            config = config.get(part)?;
+                                        }
                                     }
                                 }
                                 Some(config)
@@ -1074,15 +1081,7 @@ impl Application {
                     }
                 };
 
-                let language_server = match self.editor.language_servers.get_by_id(server_id) {
-                    Some(language_server) => language_server,
-                    None => {
-                        warn!("can't find language server with id `{}`", server_id);
-                        return;
-                    }
-                };
-
-                tokio::spawn(language_server.reply(id, reply));
+                tokio::spawn(language_server!().reply(id, reply));
             }
             Call::Invalid { id } => log::error!("LSP invalid method call id={:?}", id),
         }
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 5a844e35..9859f64b 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -23,6 +23,7 @@ use helix_core::{
     regex::{self, Regex, RegexBuilder},
     search::{self, CharMatcher},
     selection, shellwords, surround,
+    syntax::LanguageServerFeature,
     text_annotations::TextAnnotations,
     textobject,
     tree_sitter::Node,
@@ -54,13 +55,13 @@ use crate::{
     job::Callback,
     keymap::ReverseKeymap,
     ui::{
-        self, editor::InsertEvent, lsp::SignatureHelp, overlay::overlaid, FilePicker, Picker,
-        Popup, Prompt, PromptEvent,
+        self, editor::InsertEvent, lsp::SignatureHelp, overlay::overlaid, CompletionItem,
+        FilePicker, Picker, Popup, Prompt, PromptEvent,
     },
 };
 
 use crate::job::{self, Jobs};
-use futures_util::StreamExt;
+use futures_util::{stream::FuturesUnordered, StreamExt, TryStreamExt};
 use std::{collections::HashMap, fmt, future::Future};
 use std::{collections::HashSet, num::NonZeroUsize};
 
@@ -3029,7 +3030,7 @@ fn exit_select_mode(cx: &mut Context) {
 
 fn goto_first_diag(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
-    let selection = match doc.diagnostics().first() {
+    let selection = match doc.shown_diagnostics().next() {
         Some(diag) => Selection::single(diag.range.start, diag.range.end),
         None => return,
     };
@@ -3038,7 +3039,7 @@ fn goto_first_diag(cx: &mut Context) {
 
 fn goto_last_diag(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
-    let selection = match doc.diagnostics().last() {
+    let selection = match doc.shown_diagnostics().last() {
         Some(diag) => Selection::single(diag.range.start, diag.range.end),
         None => return,
     };
@@ -3054,10 +3055,9 @@ fn goto_next_diag(cx: &mut Context) {
         .cursor(doc.text().slice(..));
 
     let diag = doc
-        .diagnostics()
-        .iter()
+        .shown_diagnostics()
         .find(|diag| diag.range.start > cursor_pos)
-        .or_else(|| doc.diagnostics().first());
+        .or_else(|| doc.shown_diagnostics().next());
 
     let selection = match diag {
         Some(diag) => Selection::single(diag.range.start, diag.range.end),
@@ -3075,11 +3075,10 @@ fn goto_prev_diag(cx: &mut Context) {
         .cursor(doc.text().slice(..));
 
     let diag = doc
-        .diagnostics()
-        .iter()
+        .shown_diagnostics()
         .rev()
         .find(|diag| diag.range.start < cursor_pos)
-        .or_else(|| doc.diagnostics().last());
+        .or_else(|| doc.shown_diagnostics().last());
 
     let selection = match diag {
         // NOTE: the selection is reversed because we're jumping to the
@@ -3234,23 +3233,19 @@ pub mod insert {
         use helix_lsp::lsp;
         // if ch matches completion char, trigger completion
         let doc = doc_mut!(cx.editor);
-        let language_server = match doc.language_server() {
-            Some(language_server) => language_server,
-            None => return,
-        };
-
-        let capabilities = language_server.capabilities();
+        let trigger_completion = doc
+            .language_servers_with_feature(LanguageServerFeature::Completion)
+            .any(|ls| {
+                // TODO: what if trigger is multiple chars long
+                matches!(&ls.capabilities().completion_provider, Some(lsp::CompletionOptions {
+                    trigger_characters: Some(triggers),
+                    ..
+                }) if triggers.iter().any(|trigger| trigger.contains(ch)))
+            });
 
-        if let Some(lsp::CompletionOptions {
-            trigger_characters: Some(triggers),
-            ..
-        }) = &capabilities.completion_provider
-        {
-            // TODO: what if trigger is multiple chars long
-            if triggers.iter().any(|trigger| trigger.contains(ch)) {
-                cx.editor.clear_idle_timer();
-                super::completion(cx);
-            }
+        if trigger_completion {
+            cx.editor.clear_idle_timer();
+            super::completion(cx);
         }
     }
 
@@ -3258,12 +3253,12 @@ pub mod insert {
         use helix_lsp::lsp;
         // if ch matches signature_help char, trigger
         let doc = doc_mut!(cx.editor);
-        // The language_server!() macro is not used here since it will
-        // print an "LSP not active for current buffer" message on
-        // every keypress.
-        let language_server = match doc.language_server() {
-            Some(language_server) => language_server,
-            None => return,
+        // TODO support multiple language servers (not just the first that is found), likely by merging UI somehow
+        let Some(language_server) = doc
+            .language_servers_with_feature(LanguageServerFeature::SignatureHelp)
+            .next()
+        else {
+            return;
         };
 
         let capabilities = language_server.capabilities();
@@ -4046,55 +4041,60 @@ fn format_selections(cx: &mut Context) {
     use helix_lsp::{lsp, util::range_to_lsp_range};
 
     let (view, doc) = current!(cx.editor);
+    let view_id = view.id;
 
     // via lsp if available
     // TODO: else via tree-sitter indentation calculations
 
-    let language_server = match doc.language_server() {
-        Some(language_server) => language_server,
-        None => return,
+    if doc.selection(view_id).len() != 1 {
+        cx.editor
+            .set_error("format_selections only supports a single selection for now");
+        return;
+    }
+
+    // TODO extra LanguageServerFeature::FormatSelections?
+    // maybe such that LanguageServerFeature::Format contains it as well
+    let Some(language_server) = doc
+        .language_servers_with_feature(LanguageServerFeature::Format)
+        .find(|ls| {
+            matches!(
+                ls.capabilities().document_range_formatting_provider,
+                Some(lsp::OneOf::Left(true) | lsp::OneOf::Right(_))
+            )
+        })
+    else {
+        cx.editor
+            .set_error("No configured language server does not support range formatting");
+        return;
     };
 
+    let offset_encoding = language_server.offset_encoding();
     let ranges: Vec<lsp::Range> = doc
-        .selection(view.id)
+        .selection(view_id)
         .iter()
-        .map(|range| range_to_lsp_range(doc.text(), *range, language_server.offset_encoding()))
+        .map(|range| range_to_lsp_range(doc.text(), *range, offset_encoding))
         .collect();
 
-    if ranges.len() != 1 {
-        cx.editor
-            .set_error("format_selections only supports a single selection for now");
-        return;
-    }
-
     // TODO: handle fails
     // TODO: concurrent map over all ranges
 
     let range = ranges[0];
 
-    let request = match language_server.text_document_range_formatting(
-        doc.identifier(),
-        range,
-        lsp::FormattingOptions::default(),
-        None,
-    ) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support range formatting");
-            return;
-        }
-    };
+    let future = language_server
+        .text_document_range_formatting(
+            doc.identifier(),
+            range,
+            lsp::FormattingOptions::default(),
+            None,
+        )
+        .unwrap();
 
-    let edits = tokio::task::block_in_place(|| helix_lsp::block_on(request)).unwrap_or_default();
+    let edits = tokio::task::block_in_place(|| helix_lsp::block_on(future)).unwrap_or_default();
 
-    let transaction = helix_lsp::util::generate_transaction_from_edits(
-        doc.text(),
-        edits,
-        language_server.offset_encoding(),
-    );
+    let transaction =
+        helix_lsp::util::generate_transaction_from_edits(doc.text(), edits, offset_encoding);
 
-    doc.apply(&transaction, view.id);
+    doc.apply(&transaction, view_id);
 }
 
 fn join_selections_impl(cx: &mut Context, select_space: bool) {
@@ -4231,21 +4231,46 @@ pub fn completion(cx: &mut Context) {
         doc.savepoint(view)
     };
 
-    let language_server = match doc.language_server() {
-        Some(language_server) => language_server,
-        None => return,
-    };
-
-    let offset_encoding = language_server.offset_encoding();
     let text = savepoint.text.clone();
     let cursor = savepoint.cursor();
 
-    let pos = pos_to_lsp_pos(&text, cursor, offset_encoding);
+    let mut seen_language_servers = HashSet::new();
+
+    let mut futures: FuturesUnordered<_> = doc
+        .language_servers_with_feature(LanguageServerFeature::Completion)
+        .filter(|ls| seen_language_servers.insert(ls.id()))
+        .map(|language_server| {
+            let language_server_id = language_server.id();
+            let offset_encoding = language_server.offset_encoding();
+            let pos = pos_to_lsp_pos(&text, cursor, offset_encoding);
+            let doc_id = doc.identifier();
+            let completion_request = language_server.completion(doc_id, pos, None).unwrap();
+
+            async move {
+                let json = completion_request.await?;
+                let response: Option<lsp::CompletionResponse> = serde_json::from_value(json)?;
+
+                let items = match response {
+                    Some(lsp::CompletionResponse::Array(items)) => items,
+                    // TODO: do something with is_incomplete
+                    Some(lsp::CompletionResponse::List(lsp::CompletionList {
+                        is_incomplete: _is_incomplete,
+                        items,
+                    })) => items,
+                    None => Vec::new(),
+                }
+                .into_iter()
+                .map(|item| CompletionItem {
+                    item,
+                    language_server_id,
+                    resolved: false,
+                })
+                .collect();
 
-    let future = match language_server.completion(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => return,
-    };
+                anyhow::Ok(items)
+            }
+        })
+        .collect();
 
     // setup a channel that allows the request to be canceled
     let (tx, rx) = oneshot::channel();
@@ -4254,12 +4279,20 @@ pub fn completion(cx: &mut Context) {
     // and the associated request is automatically dropped
     cx.editor.completion_request_handle = Some(tx);
     let future = async move {
+        let items_future = async move {
+            let mut items = Vec::new();
+            // TODO if one completion request errors, all other completion requests are discarded (even if they're valid)
+            while let Some(mut lsp_items) = futures.try_next().await? {
+                items.append(&mut lsp_items);
+            }
+            anyhow::Ok(items)
+        };
         tokio::select! {
             biased;
             _ = rx => {
-                Ok(serde_json::Value::Null)
+                Ok(Vec::new())
             }
-            res = future => {
+            res = items_future => {
                 res
             }
         }
@@ -4293,9 +4326,9 @@ pub fn completion(cx: &mut Context) {
         },
     ));
 
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::CompletionResponse>| {
+    cx.jobs.callback(async move {
+        let items = future.await?;
+        let call = move |editor: &mut Editor, compositor: &mut Compositor| {
             let (view, doc) = current_ref!(editor);
             // check if the completion request is stale.
             //
@@ -4306,16 +4339,6 @@ pub fn completion(cx: &mut Context) {
                 return;
             }
 
-            let items = match response {
-                Some(lsp::CompletionResponse::Array(items)) => items,
-                // TODO: do something with is_incomplete
-                Some(lsp::CompletionResponse::List(lsp::CompletionList {
-                    is_incomplete: _is_incomplete,
-                    items,
-                })) => items,
-                None => Vec::new(),
-            };
-
             if items.is_empty() {
                 // editor.set_error("No completion available");
                 return;
@@ -4326,7 +4349,6 @@ pub fn completion(cx: &mut Context) {
                 editor,
                 savepoint,
                 items,
-                offset_encoding,
                 start_offset,
                 trigger_offset,
                 size,
@@ -4340,8 +4362,9 @@ pub fn completion(cx: &mut Context) {
             {
                 compositor.remove(SignatureHelp::ID);
             }
-        },
-    );
+        };
+        Ok(Callback::EditorCompositor(Box::new(call)))
+    });
 }
 
 // comments
@@ -5141,7 +5164,7 @@ async fn shell_impl_async(
                 helix_view::document::to_writer(&mut stdin, (encoding::UTF_8, false), &input)
                     .await?;
             }
-            Ok::<_, anyhow::Error>(())
+            anyhow::Ok(())
         });
         let (output, _) = tokio::join! {
             process.wait_with_output(),
diff --git a/helix-term/src/commands/lsp.rs b/helix-term/src/commands/lsp.rs
index 0ad6fb7e..948f3484 100644
--- a/helix-term/src/commands/lsp.rs
+++ b/helix-term/src/commands/lsp.rs
@@ -1,4 +1,4 @@
-use futures_util::FutureExt;
+use futures_util::{future::BoxFuture, stream::FuturesUnordered, FutureExt};
 use helix_lsp::{
     block_on,
     lsp::{
@@ -6,8 +6,10 @@ use helix_lsp::{
         NumberOrString,
     },
     util::{diagnostic_to_lsp_diagnostic, lsp_range_to_range, range_to_lsp_range},
-    OffsetEncoding,
+    Client, OffsetEncoding,
 };
+use serde_json::Value;
+use tokio_stream::StreamExt;
 use tui::{
     text::{Span, Spans},
     widgets::Row,
@@ -15,7 +17,9 @@ use tui::{
 
 use super::{align_view, push_jump, Align, Context, Editor, Open};
 
-use helix_core::{path, text_annotations::InlineAnnotation, Selection};
+use helix_core::{
+    path, syntax::LanguageServerFeature, text_annotations::InlineAnnotation, Selection,
+};
 use helix_view::{
     document::{DocumentInlayHints, DocumentInlayHintsId, Mode},
     editor::Action,
@@ -25,6 +29,7 @@ use helix_view::{
 
 use crate::{
     compositor::{self, Compositor},
+    job::Callback,
     ui::{
         self, lsp::SignatureHelp, overlay::overlaid, DynamicPicker, FileLocation, FilePicker,
         Popup, PromptEvent,
@@ -32,25 +37,34 @@ use crate::{
 };
 
 use std::{
-    cmp::Ordering, collections::BTreeMap, fmt::Write, future::Future, path::PathBuf, sync::Arc,
+    cmp::Ordering,
+    collections::{BTreeMap, HashSet},
+    fmt::Write,
+    future::Future,
+    path::PathBuf,
+    sync::Arc,
 };
 
-/// Gets the language server that is attached to a document, and
-/// if it's not active displays a status message. Using this macro
-/// in a context where the editor automatically queries the LSP
-/// (instead of when the user explicitly does so via a keybind like
-/// `gd`) will spam the "LSP inactive" status message confusingly.
+/// Gets the first language server that is attached to a document which supports a specific feature.
+/// If there is no configured language server that supports the feature, this displays a status message.
+/// Using this macro in a context where the editor automatically queries the LSP
+/// (instead of when the user explicitly does so via a keybind like `gd`)
+/// will spam the "No configured language server supports <feature>" status message confusingly.
 #[macro_export]
-macro_rules! language_server {
-    ($editor:expr, $doc:expr) => {
-        match $doc.language_server() {
+macro_rules! language_server_with_feature {
+    ($editor:expr, $doc:expr, $feature:expr) => {{
+        let language_server = $doc.language_servers_with_feature($feature).next();
+        match language_server {
             Some(language_server) => language_server,
             None => {
-                $editor.set_status("Language server not active for current buffer");
+                $editor.set_status(format!(
+                    "No configured language server supports {}",
+                    $feature
+                ));
                 return;
             }
         }
-    };
+    }};
 }
 
 impl ui::menu::Item for lsp::Location {
@@ -87,20 +101,30 @@ impl ui::menu::Item for lsp::Location {
     }
 }
 
-impl ui::menu::Item for lsp::SymbolInformation {
+struct SymbolInformationItem {
+    symbol: lsp::SymbolInformation,
+    offset_encoding: OffsetEncoding,
+}
+
+impl ui::menu::Item for SymbolInformationItem {
     /// Path to currently focussed document
     type Data = Option<lsp::Url>;
 
     fn format(&self, current_doc_path: &Self::Data) -> Row {
-        if current_doc_path.as_ref() == Some(&self.location.uri) {
-            self.name.as_str().into()
+        if current_doc_path.as_ref() == Some(&self.symbol.location.uri) {
+            self.symbol.name.as_str().into()
         } else {
-            match self.location.uri.to_file_path() {
+            match self.symbol.location.uri.to_file_path() {
                 Ok(path) => {
                     let get_relative_path = path::get_relative_path(path.as_path());
-                    format!("{} ({})", &self.name, get_relative_path.to_string_lossy()).into()
+                    format!(
+                        "{} ({})",
+                        &self.symbol.name,
+                        get_relative_path.to_string_lossy()
+                    )
+                    .into()
                 }
-                Err(_) => format!("{} ({})", &self.name, &self.location.uri).into(),
+                Err(_) => format!("{} ({})", &self.symbol.name, &self.symbol.location.uri).into(),
             }
         }
     }
@@ -116,6 +140,7 @@ struct DiagnosticStyles {
 struct PickerDiagnostic {
     url: lsp::Url,
     diag: lsp::Diagnostic,
+    offset_encoding: OffsetEncoding,
 }
 
 impl ui::menu::Item for PickerDiagnostic {
@@ -211,21 +236,19 @@ fn jump_to_location(
     align_view(doc, view, Align::Center);
 }
 
-fn sym_picker(
-    symbols: Vec<lsp::SymbolInformation>,
-    current_path: Option<lsp::Url>,
-    offset_encoding: OffsetEncoding,
-) -> FilePicker<lsp::SymbolInformation> {
+type SymbolPicker = FilePicker<SymbolInformationItem>;
+
+fn sym_picker(symbols: Vec<SymbolInformationItem>, current_path: Option<lsp::Url>) -> SymbolPicker {
     // TODO: drop current_path comparison and instead use workspace: bool flag?
     FilePicker::new(
         symbols,
         current_path.clone(),
-        move |cx, symbol, action| {
+        move |cx, item, action| {
             let (view, doc) = current!(cx.editor);
             push_jump(view, doc);
 
-            if current_path.as_ref() != Some(&symbol.location.uri) {
-                let uri = &symbol.location.uri;
+            if current_path.as_ref() != Some(&item.symbol.location.uri) {
+                let uri = &item.symbol.location.uri;
                 let path = match uri.to_file_path() {
                     Ok(path) => path,
                     Err(_) => {
@@ -245,7 +268,7 @@ fn sym_picker(
             let (view, doc) = current!(cx.editor);
 
             if let Some(range) =
-                lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
+                lsp_range_to_range(doc.text(), item.symbol.location.range, item.offset_encoding)
             {
                 // we flip the range so that the cursor sits on the start of the symbol
                 // (for example start of the function).
@@ -253,7 +276,7 @@ fn sym_picker(
                 align_view(doc, view, Align::Center);
             }
         },
-        move |_editor, symbol| Some(location_to_file_location(&symbol.location)),
+        move |_editor, item| Some(location_to_file_location(&item.symbol.location)),
     )
     .truncate_start(false)
 }
@@ -266,10 +289,9 @@ enum DiagnosticsFormat {
 
 fn diag_picker(
     cx: &Context,
-    diagnostics: BTreeMap<lsp::Url, Vec<lsp::Diagnostic>>,
+    diagnostics: BTreeMap<lsp::Url, Vec<(lsp::Diagnostic, usize)>>,
     current_path: Option<lsp::Url>,
     format: DiagnosticsFormat,
-    offset_encoding: OffsetEncoding,
 ) -> FilePicker<PickerDiagnostic> {
     // TODO: drop current_path comparison and instead use workspace: bool flag?
 
@@ -277,11 +299,15 @@ fn diag_picker(
     let mut flat_diag = Vec::new();
     for (url, diags) in diagnostics {
         flat_diag.reserve(diags.len());
-        for diag in diags {
-            flat_diag.push(PickerDiagnostic {
-                url: url.clone(),
-                diag,
-            });
+
+        for (diag, ls) in diags {
+            if let Some(ls) = cx.editor.language_server_by_id(ls) {
+                flat_diag.push(PickerDiagnostic {
+                    url: url.clone(),
+                    diag,
+                    offset_encoding: ls.offset_encoding(),
+                });
+            }
         }
     }
 
@@ -295,7 +321,13 @@ fn diag_picker(
     FilePicker::new(
         flat_diag,
         (styles, format),
-        move |cx, PickerDiagnostic { url, diag }, action| {
+        move |cx,
+              PickerDiagnostic {
+                  url,
+                  diag,
+                  offset_encoding,
+              },
+              action| {
             if current_path.as_ref() == Some(url) {
                 let (view, doc) = current!(cx.editor);
                 push_jump(view, doc);
@@ -306,14 +338,14 @@ fn diag_picker(
 
             let (view, doc) = current!(cx.editor);
 
-            if let Some(range) = lsp_range_to_range(doc.text(), diag.range, offset_encoding) {
+            if let Some(range) = lsp_range_to_range(doc.text(), diag.range, *offset_encoding) {
                 // we flip the range so that the cursor sits on the start of the symbol
                 // (for example start of the function).
                 doc.set_selection(view.id, Selection::single(range.head, range.anchor));
                 align_view(doc, view, Align::Center);
             }
         },
-        move |_editor, PickerDiagnostic { url, diag }| {
+        move |_editor, PickerDiagnostic { url, diag, .. }| {
             let location = lsp::Location::new(url.clone(), diag.range);
             Some(location_to_file_location(&location))
         },
@@ -323,126 +355,154 @@ fn diag_picker(
 
 pub fn symbol_picker(cx: &mut Context) {
     fn nested_to_flat(
-        list: &mut Vec<lsp::SymbolInformation>,
+        list: &mut Vec<SymbolInformationItem>,
         file: &lsp::TextDocumentIdentifier,
         symbol: lsp::DocumentSymbol,
+        offset_encoding: OffsetEncoding,
     ) {
         #[allow(deprecated)]
-        list.push(lsp::SymbolInformation {
-            name: symbol.name,
-            kind: symbol.kind,
-            tags: symbol.tags,
-            deprecated: symbol.deprecated,
-            location: lsp::Location::new(file.uri.clone(), symbol.selection_range),
-            container_name: None,
+        list.push(SymbolInformationItem {
+            symbol: lsp::SymbolInformation {
+                name: symbol.name,
+                kind: symbol.kind,
+                tags: symbol.tags,
+                deprecated: symbol.deprecated,
+                location: lsp::Location::new(file.uri.clone(), symbol.selection_range),
+                container_name: None,
+            },
+            offset_encoding,
         });
         for child in symbol.children.into_iter().flatten() {
-            nested_to_flat(list, file, child);
+            nested_to_flat(list, file, child, offset_encoding);
         }
     }
     let doc = doc!(cx.editor);
 
-    let language_server = language_server!(cx.editor, doc);
-    let current_url = doc.url();
-    let offset_encoding = language_server.offset_encoding();
+    let mut seen_language_servers = HashSet::new();
 
-    let future = match language_server.document_symbols(doc.identifier()) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support document symbols");
-            return;
-        }
-    };
-
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::DocumentSymbolResponse>| {
-            if let Some(symbols) = response {
+    let mut futures: FuturesUnordered<_> = doc
+        .language_servers_with_feature(LanguageServerFeature::DocumentSymbols)
+        .filter(|ls| seen_language_servers.insert(ls.id()))
+        .map(|language_server| {
+            let request = language_server.document_symbols(doc.identifier()).unwrap();
+            let offset_encoding = language_server.offset_encoding();
+            let doc_id = doc.identifier();
+
+            async move {
+                let json = request.await?;
+                let response: Option<lsp::DocumentSymbolResponse> = serde_json::from_value(json)?;
+                let symbols = match response {
+                    Some(symbols) => symbols,
+                    None => return anyhow::Ok(vec![]),
+                };
                 // lsp has two ways to represent symbols (flat/nested)
                 // convert the nested variant to flat, so that we have a homogeneous list
                 let symbols = match symbols {
-                    lsp::DocumentSymbolResponse::Flat(symbols) => symbols,
+                    lsp::DocumentSymbolResponse::Flat(symbols) => symbols
+                        .into_iter()
+                        .map(|symbol| SymbolInformationItem {
+                            symbol,
+                            offset_encoding,
+                        })
+                        .collect(),
                     lsp::DocumentSymbolResponse::Nested(symbols) => {
-                        let doc = doc!(editor);
                         let mut flat_symbols = Vec::new();
                         for symbol in symbols {
-                            nested_to_flat(&mut flat_symbols, &doc.identifier(), symbol)
+                            nested_to_flat(&mut flat_symbols, &doc_id, symbol, offset_encoding)
                         }
                         flat_symbols
                     }
                 };
-
-                let picker = sym_picker(symbols, current_url, offset_encoding);
-                compositor.push(Box::new(overlaid(picker)))
+                Ok(symbols)
             }
-        },
-    )
+        })
+        .collect();
+    let current_url = doc.url();
+
+    if futures.is_empty() {
+        cx.editor
+            .set_error("No configured language server supports document symbols");
+        return;
+    }
+
+    cx.jobs.callback(async move {
+        let mut symbols = Vec::new();
+        // TODO if one symbol request errors, all other requests are discarded (even if they're valid)
+        while let Some(mut lsp_items) = futures.try_next().await? {
+            symbols.append(&mut lsp_items);
+        }
+        let call = move |_editor: &mut Editor, compositor: &mut Compositor| {
+            let picker = sym_picker(symbols, current_url);
+            compositor.push(Box::new(overlaid(picker)))
+        };
+
+        Ok(Callback::EditorCompositor(Box::new(call)))
+    });
 }
 
 pub fn workspace_symbol_picker(cx: &mut Context) {
     let doc = doc!(cx.editor);
-    let current_url = doc.url();
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
-    let future = match language_server.workspace_symbols("".to_string()) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support workspace symbols");
-            return;
+
+    let get_symbols = move |pattern: String, editor: &mut Editor| {
+        let doc = doc!(editor);
+        let mut seen_language_servers = HashSet::new();
+        let mut futures: FuturesUnordered<_> = doc
+            .language_servers_with_feature(LanguageServerFeature::WorkspaceSymbols)
+            .filter(|ls| seen_language_servers.insert(ls.id()))
+            .map(|language_server| {
+                let request = language_server.workspace_symbols(pattern.clone()).unwrap();
+                let offset_encoding = language_server.offset_encoding();
+                async move {
+                    let json = request.await?;
+
+                    let response =
+                        serde_json::from_value::<Option<Vec<lsp::SymbolInformation>>>(json)?
+                            .unwrap_or_default()
+                            .into_iter()
+                            .map(|symbol| SymbolInformationItem {
+                                symbol,
+                                offset_encoding,
+                            })
+                            .collect();
+
+                    anyhow::Ok(response)
+                }
+            })
+            .collect();
+
+        if futures.is_empty() {
+            editor.set_error("No configured language server supports workspace symbols");
         }
-    };
 
-    cx.callback(
-        future,
-        move |_editor, compositor, response: Option<Vec<lsp::SymbolInformation>>| {
-            let symbols = response.unwrap_or_default();
-            let picker = sym_picker(symbols, current_url, offset_encoding);
-            let get_symbols = |query: String, editor: &mut Editor| {
-                let doc = doc!(editor);
-                let language_server = match doc.language_server() {
-                    Some(s) => s,
-                    None => {
-                        // This should not generally happen since the picker will not
-                        // even open in the first place if there is no server.
-                        return async move { Err(anyhow::anyhow!("LSP not active")) }.boxed();
-                    }
-                };
-                let symbol_request = match language_server.workspace_symbols(query) {
-                    Some(future) => future,
-                    None => {
-                        // This should also not happen since the language server must have
-                        // supported workspace symbols before to reach this block.
-                        return async move {
-                            Err(anyhow::anyhow!(
-                                "Language server does not support workspace symbols"
-                            ))
-                        }
-                        .boxed();
-                    }
-                };
+        async move {
+            let mut symbols = Vec::new();
+            // TODO if one symbol request errors, all other requests are discarded (even if they're valid)
+            while let Some(mut lsp_items) = futures.try_next().await? {
+                symbols.append(&mut lsp_items);
+            }
+            anyhow::Ok(symbols)
+        }
+        .boxed()
+    };
 
-                let future = async move {
-                    let json = symbol_request.await?;
-                    let response: Option<Vec<lsp::SymbolInformation>> =
-                        serde_json::from_value(json)?;
+    let current_url = doc.url();
+    let initial_symbols = get_symbols("".to_owned(), cx.editor);
 
-                    Ok(response.unwrap_or_default())
-                };
-                future.boxed()
-            };
+    cx.jobs.callback(async move {
+        let symbols = initial_symbols.await?;
+        let call = move |_editor: &mut Editor, compositor: &mut Compositor| {
+            let picker = sym_picker(symbols, current_url);
             let dyn_picker = DynamicPicker::new(picker, Box::new(get_symbols));
             compositor.push(Box::new(overlaid(dyn_picker)))
-        },
-    )
+        };
+
+        Ok(Callback::EditorCompositor(Box::new(call)))
+    });
 }
 
 pub fn diagnostics_picker(cx: &mut Context) {
     let doc = doc!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
     if let Some(current_url) = doc.url() {
-        let offset_encoding = language_server.offset_encoding();
         let diagnostics = cx
             .editor
             .diagnostics
@@ -454,7 +514,6 @@ pub fn diagnostics_picker(cx: &mut Context) {
             [(current_url.clone(), diagnostics)].into(),
             Some(current_url),
             DiagnosticsFormat::HideSourcePath,
-            offset_encoding,
         );
         cx.push_layer(Box::new(overlaid(picker)));
     }
@@ -462,24 +521,27 @@ pub fn diagnostics_picker(cx: &mut Context) {
 
 pub fn workspace_diagnostics_picker(cx: &mut Context) {
     let doc = doc!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
     let current_url = doc.url();
-    let offset_encoding = language_server.offset_encoding();
+    // TODO not yet filtered by LanguageServerFeature, need to do something similar as Document::shown_diagnostics here for all open documents
     let diagnostics = cx.editor.diagnostics.clone();
     let picker = diag_picker(
         cx,
         diagnostics,
         current_url,
         DiagnosticsFormat::ShowSourcePath,
-        offset_encoding,
     );
     cx.push_layer(Box::new(overlaid(picker)));
 }
 
-impl ui::menu::Item for lsp::CodeActionOrCommand {
+struct CodeActionOrCommandItem {
+    lsp_item: lsp::CodeActionOrCommand,
+    language_server_id: usize,
+}
+
+impl ui::menu::Item for CodeActionOrCommandItem {
     type Data = ();
     fn format(&self, _data: &Self::Data) -> Row {
-        match self {
+        match &self.lsp_item {
             lsp::CodeActionOrCommand::CodeAction(action) => action.title.as_str().into(),
             lsp::CodeActionOrCommand::Command(command) => command.title.as_str().into(),
         }
@@ -546,45 +608,42 @@ fn action_fixes_diagnostics(action: &CodeActionOrCommand) -> bool {
 pub fn code_action(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
 
-    let language_server = language_server!(cx.editor, doc);
-
     let selection_range = doc.selection(view.id).primary();
-    let offset_encoding = language_server.offset_encoding();
 
-    let range = range_to_lsp_range(doc.text(), selection_range, offset_encoding);
+    let mut seen_language_servers = HashSet::new();
 
-    let future = match language_server.code_actions(
-        doc.identifier(),
-        range,
-        // Filter and convert overlapping diagnostics
-        lsp::CodeActionContext {
-            diagnostics: doc
-                .diagnostics()
-                .iter()
-                .filter(|&diag| {
-                    selection_range
-                        .overlaps(&helix_core::Range::new(diag.range.start, diag.range.end))
-                })
-                .map(|diag| diagnostic_to_lsp_diagnostic(doc.text(), diag, offset_encoding))
-                .collect(),
-            only: None,
-            trigger_kind: Some(CodeActionTriggerKind::INVOKED),
-        },
-    ) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support code actions");
-            return;
-        }
-    };
-
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::CodeActionResponse>| {
+    let mut futures: FuturesUnordered<_> = doc
+        .language_servers_with_feature(LanguageServerFeature::CodeAction)
+        .filter(|ls| seen_language_servers.insert(ls.id()))
+        // TODO this should probably already been filtered in something like "language_servers_with_feature"
+        .filter_map(|language_server| {
+            let offset_encoding = language_server.offset_encoding();
+            let language_server_id = language_server.id();
+            let range = range_to_lsp_range(doc.text(), selection_range, offset_encoding);
+            // Filter and convert overlapping diagnostics
+            let code_action_context = lsp::CodeActionContext {
+                diagnostics: doc
+                    .diagnostics()
+                    .iter()
+                    .filter(|&diag| {
+                        selection_range
+                            .overlaps(&helix_core::Range::new(diag.range.start, diag.range.end))
+                    })
+                    .map(|diag| diagnostic_to_lsp_diagnostic(doc.text(), diag, offset_encoding))
+                    .collect(),
+                only: None,
+                trigger_kind: Some(CodeActionTriggerKind::INVOKED),
+            };
+            let code_action_request =
+                language_server.code_actions(doc.identifier(), range, code_action_context)?;
+            Some((code_action_request, language_server_id))
+        })
+        .map(|(request, ls_id)| async move {
+            let json = request.await?;
+            let response: Option<lsp::CodeActionResponse> = serde_json::from_value(json)?;
             let mut actions = match response {
                 Some(a) => a,
-                None => return,
+                None => return anyhow::Ok(Vec::new()),
             };
 
             // remove disabled code actions
@@ -596,11 +655,6 @@ pub fn code_action(cx: &mut Context) {
                 )
             });
 
-            if actions.is_empty() {
-                editor.set_status("No code actions available");
-                return;
-            }
-
             // Sort codeactions into a useful order. This behaviour is only partially described in the LSP spec.
             // Many details are modeled after vscode because language servers are usually tested against it.
             // VScode sorts the codeaction two times:
@@ -636,18 +690,51 @@ pub fn code_action(cx: &mut Context) {
                     .reverse()
             });
 
-            let mut picker = ui::Menu::new(actions, (), move |editor, code_action, event| {
+            Ok(actions
+                .into_iter()
+                .map(|lsp_item| CodeActionOrCommandItem {
+                    lsp_item,
+                    language_server_id: ls_id,
+                })
+                .collect())
+        })
+        .collect();
+
+    if futures.is_empty() {
+        cx.editor
+            .set_error("No configured language server supports code actions");
+        return;
+    }
+
+    cx.jobs.callback(async move {
+        let mut actions = Vec::new();
+        // TODO if one code action request errors, all other requests are ignored (even if they're valid)
+        while let Some(mut lsp_items) = futures.try_next().await? {
+            actions.append(&mut lsp_items);
+        }
+
+        let call = move |editor: &mut Editor, compositor: &mut Compositor| {
+            if actions.is_empty() {
+                editor.set_error("No code actions available");
+                return;
+            }
+            let mut picker = ui::Menu::new(actions, (), move |editor, action, event| {
                 if event != PromptEvent::Validate {
                     return;
                 }
 
                 // always present here
-                let code_action = code_action.unwrap();
+                let action = action.unwrap();
+                let Some(language_server) = editor.language_server_by_id(action.language_server_id) else {
+                    editor.set_error("Language Server disappeared");
+                    return;
+                };
+                let offset_encoding = language_server.offset_encoding();
 
-                match code_action {
+                match &action.lsp_item {
                     lsp::CodeActionOrCommand::Command(command) => {
                         log::debug!("code action command: {:?}", command);
-                        execute_lsp_command(editor, command.clone());
+                        execute_lsp_command(editor, action.language_server_id, command.clone());
                     }
                     lsp::CodeActionOrCommand::CodeAction(code_action) => {
                         log::debug!("code action: {:?}", code_action);
@@ -659,7 +746,7 @@ pub fn code_action(cx: &mut Context) {
                         // if code action provides both edit and command first the edit
                         // should be applied and then the command
                         if let Some(command) = &code_action.command {
-                            execute_lsp_command(editor, command.clone());
+                            execute_lsp_command(editor, action.language_server_id, command.clone());
                         }
                     }
                 }
@@ -668,8 +755,10 @@ pub fn code_action(cx: &mut Context) {
 
             let popup = Popup::new("code-action", picker).with_scrollbar(false);
             compositor.replace_or_push("code-action", popup);
-        },
-    )
+        };
+
+        Ok(Callback::EditorCompositor(Box::new(call)))
+    });
 }
 
 impl ui::menu::Item for lsp::Command {
@@ -679,13 +768,13 @@ impl ui::menu::Item for lsp::Command {
     }
 }
 
-pub fn execute_lsp_command(editor: &mut Editor, cmd: lsp::Command) {
-    let doc = doc!(editor);
-    let language_server = language_server!(editor, doc);
-
+pub fn execute_lsp_command(editor: &mut Editor, language_server_id: usize, cmd: lsp::Command) {
     // the command is executed on the server and communicated back
     // to the client asynchronously using workspace edits
-    let future = match language_server.command(cmd) {
+    let future = match editor
+        .language_server_by_id(language_server_id)
+        .and_then(|language_server| language_server.command(cmd))
+    {
         Some(future) => future,
         None => {
             editor.set_error("Language server does not support executing commands");
@@ -977,21 +1066,17 @@ fn to_locations(definitions: Option<lsp::GotoDefinitionResponse>) -> Vec<lsp::Lo
     }
 }
 
-pub fn goto_declaration(cx: &mut Context) {
+fn goto_single_impl<P, F>(cx: &mut Context, feature: LanguageServerFeature, request_provider: P)
+where
+    P: Fn(&Client, lsp::Position, lsp::TextDocumentIdentifier) -> Option<F>,
+    F: Future<Output = helix_lsp::Result<serde_json::Value>> + 'static + Send,
+{
     let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
 
+    let language_server = language_server_with_feature!(cx.editor, doc, feature);
+    let offset_encoding = language_server.offset_encoding();
     let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.goto_declaration(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support goto-declaration");
-            return;
-        }
-    };
+    let future = request_provider(language_server, pos, doc.identifier()).unwrap();
 
     cx.callback(
         future,
@@ -1002,102 +1087,56 @@ pub fn goto_declaration(cx: &mut Context) {
     );
 }
 
-pub fn goto_definition(cx: &mut Context) {
-    let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
-
-    let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.goto_definition(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support goto-definition");
-            return;
-        }
-    };
+pub fn goto_declaration(cx: &mut Context) {
+    goto_single_impl(
+        cx,
+        LanguageServerFeature::GotoDeclaration,
+        |ls, pos, doc_id| ls.goto_declaration(doc_id, pos, None),
+    );
+}
 
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::GotoDefinitionResponse>| {
-            let items = to_locations(response);
-            goto_impl(editor, compositor, items, offset_encoding);
-        },
+pub fn goto_definition(cx: &mut Context) {
+    goto_single_impl(
+        cx,
+        LanguageServerFeature::GotoDefinition,
+        |ls, pos, doc_id| ls.goto_definition(doc_id, pos, None),
     );
 }
 
 pub fn goto_type_definition(cx: &mut Context) {
-    let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
-
-    let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.goto_type_definition(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support goto-type-definition");
-            return;
-        }
-    };
-
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::GotoDefinitionResponse>| {
-            let items = to_locations(response);
-            goto_impl(editor, compositor, items, offset_encoding);
-        },
+    goto_single_impl(
+        cx,
+        LanguageServerFeature::GotoTypeDefinition,
+        |ls, pos, doc_id| ls.goto_type_definition(doc_id, pos, None),
     );
 }
 
 pub fn goto_implementation(cx: &mut Context) {
-    let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
-
-    let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.goto_implementation(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support goto-implementation");
-            return;
-        }
-    };
-
-    cx.callback(
-        future,
-        move |editor, compositor, response: Option<lsp::GotoDefinitionResponse>| {
-            let items = to_locations(response);
-            goto_impl(editor, compositor, items, offset_encoding);
-        },
+    goto_single_impl(
+        cx,
+        LanguageServerFeature::GotoImplementation,
+        |ls, pos, doc_id| ls.goto_implementation(doc_id, pos, None),
     );
 }
 
 pub fn goto_reference(cx: &mut Context) {
     let config = cx.editor.config();
     let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
 
+    // TODO could probably support multiple language servers,
+    // not sure if there's a real practical use case for this though
+    let language_server =
+        language_server_with_feature!(cx.editor, doc, LanguageServerFeature::GotoReference);
+    let offset_encoding = language_server.offset_encoding();
     let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.goto_reference(
-        doc.identifier(),
-        pos,
-        config.lsp.goto_reference_include_declaration,
-        None,
-    ) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support goto-reference");
-            return;
-        }
-    };
+    let future = language_server
+        .goto_reference(
+            doc.identifier(),
+            pos,
+            config.lsp.goto_reference_include_declaration,
+            None,
+        )
+        .unwrap();
 
     cx.callback(
         future,
@@ -1108,7 +1147,7 @@ pub fn goto_reference(cx: &mut Context) {
     );
 }
 
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 pub enum SignatureHelpInvoked {
     Manual,
     Automatic,
@@ -1120,35 +1159,31 @@ pub fn signature_help(cx: &mut Context) {
 
 pub fn signature_help_impl(cx: &mut Context, invoked: SignatureHelpInvoked) {
     let (view, doc) = current!(cx.editor);
-    let was_manually_invoked = invoked == SignatureHelpInvoked::Manual;
-
-    let language_server = match doc.language_server() {
-        Some(language_server) => language_server,
-        None => {
-            // Do not show the message if signature help was invoked
-            // automatically on backspace, trigger characters, etc.
-            if was_manually_invoked {
-                cx.editor
-                    .set_status("Language server not active for current buffer");
-            }
-            return;
-        }
-    };
-    let offset_encoding = language_server.offset_encoding();
 
-    let pos = doc.position(view.id, offset_encoding);
+    // TODO merge multiple language server signature help into one instead of just taking the first language server that supports it
+    let future = doc
+        .language_servers_with_feature(LanguageServerFeature::SignatureHelp)
+        .find_map(|language_server| {
+            let pos = doc.position(view.id, language_server.offset_encoding());
+            language_server.text_document_signature_help(doc.identifier(), pos, None)
+        });
 
-    let future = match language_server.text_document_signature_help(doc.identifier(), pos, None) {
-        Some(f) => f,
-        None => {
-            if was_manually_invoked {
-                cx.editor
-                    .set_error("Language server does not support signature-help");
-            }
-            return;
+    let Some(future) = future else {
+        // Do not show the message if signature help was invoked
+        // automatically on backspace, trigger characters, etc.
+        if invoked == SignatureHelpInvoked::Manual {
+            cx.editor.set_error("No configured language server supports signature-help");
         }
+        return;
     };
+    signature_help_impl_with_future(cx, future.boxed(), invoked);
+}
 
+pub fn signature_help_impl_with_future(
+    cx: &mut Context,
+    future: BoxFuture<'static, helix_lsp::Result<Value>>,
+    invoked: SignatureHelpInvoked,
+) {
     cx.callback(
         future,
         move |editor, compositor, response: Option<lsp::SignatureHelp>| {
@@ -1156,7 +1191,7 @@ pub fn signature_help_impl(cx: &mut Context, invoked: SignatureHelpInvoked) {
 
             if !(config.lsp.auto_signature_help
                 || SignatureHelp::visible_popup(compositor).is_some()
-                || was_manually_invoked)
+                || invoked == SignatureHelpInvoked::Manual)
             {
                 return;
             }
@@ -1165,7 +1200,7 @@ pub fn signature_help_impl(cx: &mut Context, invoked: SignatureHelpInvoked) {
             // it very probably means the server was a little slow to respond and the user has
             // already moved on to something else, making a signature help popup will just be an
             // annoyance, see https://github.com/helix-editor/helix/issues/3112
-            if !was_manually_invoked && editor.mode != Mode::Insert {
+            if invoked == SignatureHelpInvoked::Automatic && editor.mode != Mode::Insert {
                 return;
             }
 
@@ -1255,21 +1290,15 @@ pub fn signature_help_impl(cx: &mut Context, invoked: SignatureHelpInvoked) {
 
 pub fn hover(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
 
+    // TODO support multiple language servers (merge UI somehow)
+    let language_server =
+        language_server_with_feature!(cx.editor, doc, LanguageServerFeature::Hover);
     // TODO: factor out a doc.position_identifier() that returns lsp::TextDocumentPositionIdentifier
-
-    let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.text_document_hover(doc.identifier(), pos, None) {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support hover");
-            return;
-        }
-    };
+    let pos = doc.position(view.id, language_server.offset_encoding());
+    let future = language_server
+        .text_document_hover(doc.identifier(), pos, None)
+        .unwrap();
 
     cx.callback(
         future,
@@ -1349,7 +1378,11 @@ pub fn rename_symbol(cx: &mut Context) {
         }
     }
 
-    fn create_rename_prompt(editor: &Editor, prefill: String) -> Box<ui::Prompt> {
+    fn create_rename_prompt(
+        editor: &Editor,
+        prefill: String,
+        language_server_id: Option<usize>,
+    ) -> Box<ui::Prompt> {
         let prompt = ui::Prompt::new(
             "rename-to:".into(),
             None,
@@ -1358,22 +1391,22 @@ pub fn rename_symbol(cx: &mut Context) {
                 if event != PromptEvent::Validate {
                     return;
                 }
-
                 let (view, doc) = current!(cx.editor);
-                let language_server = language_server!(cx.editor, doc);
-                let offset_encoding = language_server.offset_encoding();
 
+                let Some(language_server) = doc
+                    .language_servers_with_feature(LanguageServerFeature::RenameSymbol)
+                    .find(|ls| language_server_id.map_or(true, |id| id == ls.id()))
+                else {
+                    cx.editor.set_error("No configured language server supports symbol renaming");
+                    return;
+                };
+
+                let offset_encoding = language_server.offset_encoding();
                 let pos = doc.position(view.id, offset_encoding);
+                let future = language_server
+                    .rename_symbol(doc.identifier(), pos, input.to_string())
+                    .unwrap();
 
-                let future =
-                    match language_server.rename_symbol(doc.identifier(), pos, input.to_string()) {
-                        Some(future) => future,
-                        None => {
-                            cx.editor
-                                .set_error("Language server does not support symbol renaming");
-                            return;
-                        }
-                    };
                 match block_on(future) {
                     Ok(edits) => {
                         let _ = apply_workspace_edit(cx.editor, offset_encoding, &edits);
@@ -1387,21 +1420,28 @@ pub fn rename_symbol(cx: &mut Context) {
         Box::new(prompt)
     }
 
-    let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
-    let offset_encoding = language_server.offset_encoding();
-
-    if !language_server.supports_rename() {
-        cx.editor
-            .set_error("Language server does not support symbol renaming");
-        return;
-    }
-
-    let pos = doc.position(view.id, offset_encoding);
+    let (view, doc) = current_ref!(cx.editor);
+
+    let language_server_with_prepare_rename_support = doc
+        .language_servers_with_feature(LanguageServerFeature::RenameSymbol)
+        .find(|ls| {
+            matches!(
+                ls.capabilities().rename_provider,
+                Some(lsp::OneOf::Right(lsp::RenameOptions {
+                    prepare_provider: Some(true),
+                    ..
+                }))
+            )
+        });
 
-    match language_server.prepare_rename(doc.identifier(), pos) {
-        // Language server supports textDocument/prepareRename, use it.
-        Some(future) => cx.callback(
+    if let Some(language_server) = language_server_with_prepare_rename_support {
+        let ls_id = language_server.id();
+        let offset_encoding = language_server.offset_encoding();
+        let pos = doc.position(view.id, offset_encoding);
+        let future = language_server
+            .prepare_rename(doc.identifier(), pos)
+            .unwrap();
+        cx.callback(
             future,
             move |editor, compositor, response: Option<lsp::PrepareRenameResponse>| {
                 let prefill = match get_prefill_from_lsp_response(editor, offset_encoding, response)
@@ -1413,39 +1453,27 @@ pub fn rename_symbol(cx: &mut Context) {
                     }
                 };
 
-                let prompt = create_rename_prompt(editor, prefill);
+                let prompt = create_rename_prompt(editor, prefill, Some(ls_id));
 
                 compositor.push(prompt);
             },
-        ),
-        // Language server does not support textDocument/prepareRename, fall back
-        // to word boundary selection.
-        None => {
-            let prefill = get_prefill_from_word_boundary(cx.editor);
-
-            let prompt = create_rename_prompt(cx.editor, prefill);
-
-            cx.push_layer(prompt);
-        }
-    };
+        );
+    } else {
+        let prefill = get_prefill_from_word_boundary(cx.editor);
+        let prompt = create_rename_prompt(cx.editor, prefill, None);
+        cx.push_layer(prompt);
+    }
 }
 
 pub fn select_references_to_symbol_under_cursor(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
-    let language_server = language_server!(cx.editor, doc);
+    let language_server =
+        language_server_with_feature!(cx.editor, doc, LanguageServerFeature::DocumentHighlight);
     let offset_encoding = language_server.offset_encoding();
-
     let pos = doc.position(view.id, offset_encoding);
-
-    let future = match language_server.text_document_document_highlight(doc.identifier(), pos, None)
-    {
-        Some(future) => future,
-        None => {
-            cx.editor
-                .set_error("Language server does not support document highlight");
-            return;
-        }
-    };
+    let future = language_server
+        .text_document_document_highlight(doc.identifier(), pos, None)
+        .unwrap();
 
     cx.callback(
         future,
@@ -1455,8 +1483,6 @@ pub fn select_references_to_symbol_under_cursor(cx: &mut Context) {
                 _ => return,
             };
             let (view, doc) = current!(editor);
-            let language_server = language_server!(editor, doc);
-            let offset_encoding = language_server.offset_encoding();
             let text = doc.text();
             let pos = doc.selection(view.id).primary().head;
 
@@ -1502,63 +1528,51 @@ fn compute_inlay_hints_for_view(
     let view_id = view.id;
     let doc_id = view.doc;
 
-    let language_server = doc.language_server()?;
-
-    let capabilities = language_server.capabilities();
-
-    let (future, new_doc_inlay_hints_id) = match capabilities.inlay_hint_provider {
-        Some(
-            lsp::OneOf::Left(true)
-            | lsp::OneOf::Right(lsp::InlayHintServerCapabilities::Options(_)),
-        ) => {
-            let doc_text = doc.text();
-            let len_lines = doc_text.len_lines();
-
-            // Compute ~3 times the current view height of inlay hints, that way some scrolling
-            // will not show half the view with hints and half without while still being faster
-            // than computing all the hints for the full file (which could be dozens of time
-            // longer than the view is).
-            let view_height = view.inner_height();
-            let first_visible_line =
-                doc_text.char_to_line(view.offset.anchor.min(doc_text.len_chars()));
-            let first_line = first_visible_line.saturating_sub(view_height);
-            let last_line = first_visible_line
-                .saturating_add(view_height.saturating_mul(2))
-                .min(len_lines);
-
-            let new_doc_inlay_hint_id = DocumentInlayHintsId {
-                first_line,
-                last_line,
-            };
-            // Don't recompute the annotations in case nothing has changed about the view
-            if !doc.inlay_hints_oudated
-                && doc
-                    .inlay_hints(view_id)
-                    .map_or(false, |dih| dih.id == new_doc_inlay_hint_id)
-            {
-                return None;
-            }
+    let language_server = doc
+        .language_servers_with_feature(LanguageServerFeature::InlayHints)
+        .next()?;
+
+    let doc_text = doc.text();
+    let len_lines = doc_text.len_lines();
+
+    // Compute ~3 times the current view height of inlay hints, that way some scrolling
+    // will not show half the view with hints and half without while still being faster
+    // than computing all the hints for the full file (which could be dozens of time
+    // longer than the view is).
+    let view_height = view.inner_height();
+    let first_visible_line = doc_text.char_to_line(view.offset.anchor.min(doc_text.len_chars()));
+    let first_line = first_visible_line.saturating_sub(view_height);
+    let last_line = first_visible_line
+        .saturating_add(view_height.saturating_mul(2))
+        .min(len_lines);
+
+    let new_doc_inlay_hints_id = DocumentInlayHintsId {
+        first_line,
+        last_line,
+    };
+    // Don't recompute the annotations in case nothing has changed about the view
+    if !doc.inlay_hints_oudated
+        && doc
+            .inlay_hints(view_id)
+            .map_or(false, |dih| dih.id == new_doc_inlay_hints_id)
+    {
+        return None;
+    }
 
-            let doc_slice = doc_text.slice(..);
-            let first_char_in_range = doc_slice.line_to_char(first_line);
-            let last_char_in_range = doc_slice.line_to_char(last_line);
+    let doc_slice = doc_text.slice(..);
+    let first_char_in_range = doc_slice.line_to_char(first_line);
+    let last_char_in_range = doc_slice.line_to_char(last_line);
 
-            let range = helix_lsp::util::range_to_lsp_range(
-                doc_text,
-                helix_core::Range::new(first_char_in_range, last_char_in_range),
-                language_server.offset_encoding(),
-            );
+    let range = helix_lsp::util::range_to_lsp_range(
+        doc_text,
+        helix_core::Range::new(first_char_in_range, last_char_in_range),
+        language_server.offset_encoding(),
+    );
 
-            (
-                language_server.text_document_range_inlay_hints(doc.identifier(), range, None),
-                new_doc_inlay_hint_id,
-            )
-        }
-        _ => return None,
-    };
+    let offset_encoding = language_server.offset_encoding();
 
     let callback = super::make_job_callback(
-        future?,
+        language_server.text_document_range_inlay_hints(doc.identifier(), range, None)?,
         move |editor, _compositor, response: Option<Vec<lsp::InlayHint>>| {
             // The config was modified or the window was closed while the request was in flight
             if !editor.config().lsp.display_inlay_hints || editor.tree.try_get(view_id).is_none() {
@@ -1572,8 +1586,8 @@ fn compute_inlay_hints_for_view(
             };
 
             // If we have neither hints nor an LSP, empty the inlay hints since they're now oudated
-            let (mut hints, offset_encoding) = match (response, doc.language_server()) {
-                (Some(h), Some(ls)) if !h.is_empty() => (h, ls.offset_encoding()),
+            let mut hints = match response {
+                Some(hints) if !hints.is_empty() => hints,
                 _ => {
                     doc.set_inlay_hints(
                         view_id,
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
index 81a24059..706442e4 100644
--- a/helix-term/src/commands/typed.rs
+++ b/helix-term/src/commands/typed.rs
@@ -1329,26 +1329,22 @@ fn lsp_workspace_command(
     if event != PromptEvent::Validate {
         return Ok(());
     }
-
-    let (_, doc) = current!(cx.editor);
-
-    let language_server = match doc.language_server() {
-        Some(language_server) => language_server,
-        None => {
-            cx.editor
-                .set_status("Language server not active for current buffer");
-            return Ok(());
-        }
+    let doc = doc!(cx.editor);
+    let Some((language_server_id, options)) = doc
+        .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
+        .find_map(|ls| {
+            ls.capabilities()
+                .execute_command_provider
+                .as_ref()
+                .map(|options| (ls.id(), options))
+        })
+    else {
+        cx.editor.set_status(
+             "No active language servers for this document support workspace commands",
+        );
+        return Ok(());
     };
 
-    let options = match &language_server.capabilities().execute_command_provider {
-        Some(options) => options,
-        None => {
-            cx.editor
-                .set_status("Workspace commands are not supported for this language server");
-            return Ok(());
-        }
-    };
     if args.is_empty() {
         let commands = options
             .commands
@@ -1362,8 +1358,8 @@ fn lsp_workspace_command(
         let callback = async move {
             let call: job::Callback = Callback::EditorCompositor(Box::new(
                 move |_editor: &mut Editor, compositor: &mut Compositor| {
-                    let picker = ui::Picker::new(commands, (), |cx, command, _action| {
-                        execute_lsp_command(cx.editor, command.clone());
+                    let picker = ui::Picker::new(commands, (), move |cx, command, _action| {
+                        execute_lsp_command(cx.editor, language_server_id, command.clone());
                     });
                     compositor.push(Box::new(overlaid(picker)))
                 },
@@ -1376,6 +1372,7 @@ fn lsp_workspace_command(
         if options.commands.iter().any(|c| c == &command) {
             execute_lsp_command(
                 cx.editor,
+                language_server_id,
                 helix_lsp::lsp::Command {
                     title: command.clone(),
                     arguments: None,
@@ -1407,7 +1404,6 @@ fn lsp_restart(
         .language_config()
         .context("LSP not defined for the current document")?;
 
-    let scope = config.scope.clone();
     cx.editor.language_servers.restart(
         config,
         doc.path(),
@@ -1420,13 +1416,22 @@ fn lsp_restart(
         .editor
         .documents()
         .filter_map(|doc| match doc.language_config() {
-            Some(config) if config.scope.eq(&scope) => Some(doc.id()),
+            Some(config)
+                if config.language_servers.iter().any(|ls| {
+                    config
+                        .language_servers
+                        .iter()
+                        .any(|restarted_ls| restarted_ls.name == ls.name)
+                }) =>
+            {
+                Some(doc.id())
+            }
             _ => None,
         })
         .collect();
 
     for document_id in document_ids_to_refresh {
-        cx.editor.refresh_language_server(document_id);
+        cx.editor.refresh_language_servers(document_id);
     }
 
     Ok(())
@@ -1441,22 +1446,18 @@ fn lsp_stop(
         return Ok(());
     }
 
-    let doc = doc!(cx.editor);
+    let ls_shutdown_names = doc!(cx.editor)
+        .language_servers()
+        .map(|ls| ls.name().to_string())
+        .collect::<Vec<_>>();
 
-    let ls_id = doc
-        .language_server()
-        .map(|ls| ls.id())
-        .context("LSP not running for the current document")?;
+    for ls_name in &ls_shutdown_names {
+        cx.editor.language_servers.stop(ls_name);
 
-    let config = doc
-        .language_config()
-        .context("LSP not defined for the current document")?;
-    cx.editor.language_servers.stop(config);
-
-    for doc in cx.editor.documents_mut() {
-        if doc.language_server().map_or(false, |ls| ls.id() == ls_id) {
-            doc.set_language_server(None);
-            doc.set_diagnostics(Default::default());
+        for doc in cx.editor.documents_mut() {
+            if let Some(client) = doc.remove_language_server_by_name(ls_name) {
+                doc.clear_diagnostics(client.id());
+            }
         }
     }
 
@@ -1850,7 +1851,7 @@ fn language(
     doc.detect_indent_and_line_ending();
 
     let id = doc.id();
-    cx.editor.refresh_language_server(id);
+    cx.editor.refresh_language_servers(id);
     Ok(())
 }
 
@@ -2588,14 +2589,14 @@ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
         TypableCommand {
             name: "lsp-restart",
             aliases: &[],
-            doc: "Restarts the Language Server that is in use by the current doc",
+            doc: "Restarts the language servers used by the current doc",
             fun: lsp_restart,
             signature: CommandSignature::none(),
         },
         TypableCommand {
             name: "lsp-stop",
             aliases: &[],
-            doc: "Stops the Language Server that is in use by the current doc",
+            doc: "Stops the language servers that are used by the current doc",
             fun: lsp_stop,
             signature: CommandSignature::none(),
         },
diff --git a/helix-term/src/health.rs b/helix-term/src/health.rs
index 480c2c67..8f921877 100644
--- a/helix-term/src/health.rs
+++ b/helix-term/src/health.rs
@@ -192,10 +192,14 @@ pub fn languages_all() -> std::io::Result<()> {
     for lang in &syn_loader_conf.language {
         column(&lang.language_id, Color::Reset);
 
-        let lsp = lang
-            .language_server
-            .as_ref()
-            .map(|lsp| lsp.command.to_string());
+        // TODO multiple language servers (check binary for each supported language server, not just the first)
+
+        let lsp = lang.language_servers.first().and_then(|ls| {
+            syn_loader_conf
+                .language_server
+                .get(&ls.name)
+                .map(|config| config.command.clone())
+        });
         check_binary(lsp);
 
         let dap = lang.debugger.as_ref().map(|dap| dap.command.to_string());
@@ -264,11 +268,15 @@ pub fn language(lang_str: String) -> std::io::Result<()> {
         }
     };
 
+    // TODO multiple language servers
     probe_protocol(
         "language server",
-        lang.language_server
-            .as_ref()
-            .map(|lsp| lsp.command.to_string()),
+        lang.language_servers.first().and_then(|ls| {
+            syn_loader_conf
+                .language_server
+                .get(&ls.name)
+                .map(|config| config.command.clone())
+        }),
     )?;
 
     probe_protocol(
diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
index c5c40580..d997e8ae 100644
--- a/helix-term/src/ui/completion.rs
+++ b/helix-term/src/ui/completion.rs
@@ -15,7 +15,7 @@ use helix_view::{graphics::Rect, Document, Editor};
 use crate::commands;
 use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};
 
-use helix_lsp::{lsp, util};
+use helix_lsp::{lsp, util, OffsetEncoding};
 
 impl menu::Item for CompletionItem {
     type Data = ();
@@ -38,6 +38,7 @@ impl menu::Item for CompletionItem {
             || self.item.tags.as_ref().map_or(false, |tags| {
                 tags.contains(&lsp::CompletionItemTag::DEPRECATED)
             });
+
         menu::Row::new(vec![
             menu::Cell::from(Span::styled(
                 self.item.label.as_str(),
@@ -79,19 +80,15 @@ impl menu::Item for CompletionItem {
                 }
                 None => "",
             }),
-            // self.detail.as_deref().unwrap_or("")
-            // self.label_details
-            //     .as_ref()
-            //     .or(self.detail())
-            //     .as_str(),
         ])
     }
 }
 
 #[derive(Debug, PartialEq, Default, Clone)]
-struct CompletionItem {
-    item: lsp::CompletionItem,
-    resolved: bool,
+pub struct CompletionItem {
+    pub item: lsp::CompletionItem,
+    pub language_server_id: usize,
+    pub resolved: bool,
 }
 
 /// Wraps a Menu.
@@ -109,29 +106,21 @@ impl Completion {
     pub fn new(
         editor: &Editor,
         savepoint: Arc<SavePoint>,
-        mut items: Vec<lsp::CompletionItem>,
-        offset_encoding: helix_lsp::OffsetEncoding,
+        mut items: Vec<CompletionItem>,
         start_offset: usize,
         trigger_offset: usize,
     ) -> Self {
         let replace_mode = editor.config().completion_replace;
         // Sort completion items according to their preselect status (given by the LSP server)
-        items.sort_by_key(|item| !item.preselect.unwrap_or(false));
-        let items = items
-            .into_iter()
-            .map(|item| CompletionItem {
-                item,
-                resolved: false,
-            })
-            .collect();
+        items.sort_by_key(|item| !item.item.preselect.unwrap_or(false));
 
         // Then create the menu
         let menu = Menu::new(items, (), move |editor: &mut Editor, item, event| {
             fn item_to_transaction(
                 doc: &Document,
                 view_id: ViewId,
-                item: &CompletionItem,
-                offset_encoding: helix_lsp::OffsetEncoding,
+                item: &lsp::CompletionItem,
+                offset_encoding: OffsetEncoding,
                 trigger_offset: usize,
                 include_placeholder: bool,
                 replace_mode: bool,
@@ -141,7 +130,7 @@ impl Completion {
                 let text = doc.text().slice(..);
                 let primary_cursor = selection.primary().cursor(text);
 
-                let (edit_offset, new_text) = if let Some(edit) = &item.item.text_edit {
+                let (edit_offset, new_text) = if let Some(edit) = &item.text_edit {
                     let edit = match edit {
                         lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
                         lsp::CompletionTextEdit::InsertAndReplace(item) => {
@@ -164,10 +153,9 @@ impl Completion {
                     (Some((start_offset, end_offset)), edit.new_text)
                 } else {
                     let new_text = item
-                        .item
                         .insert_text
                         .clone()
-                        .unwrap_or_else(|| item.item.label.clone());
+                        .unwrap_or_else(|| item.label.clone());
                     // check that we are still at the correct savepoint
                     // we can still generate a transaction regardless but if the
                     // document changed (and not just the selection) then we will
@@ -176,9 +164,9 @@ impl Completion {
                     (None, new_text)
                 };
 
-                if matches!(item.item.kind, Some(lsp::CompletionItemKind::SNIPPET))
+                if matches!(item.kind, Some(lsp::CompletionItemKind::SNIPPET))
                     || matches!(
-                        item.item.insert_text_format,
+                        item.insert_text_format,
                         Some(lsp::InsertTextFormat::SNIPPET)
                     )
                 {
@@ -223,6 +211,23 @@ impl Completion {
 
             let (view, doc) = current!(editor);
 
+            macro_rules! language_server {
+                ($item:expr) => {
+                    match editor
+                        .language_servers
+                        .get_by_id($item.language_server_id)
+                    {
+                        Some(ls) => ls,
+                        None => {
+                            editor.set_error("completions are outdated");
+                            // TODO close the completion menu somehow,
+                            // currently there is no trivial way to access the EditorView to close the completion menu
+                            return;
+                        }
+                    }
+                };
+            }
+
             match event {
                 PromptEvent::Abort => {}
                 PromptEvent::Update => {
@@ -250,8 +255,8 @@ impl Completion {
                     let transaction = item_to_transaction(
                         doc,
                         view.id,
-                        item,
-                        offset_encoding,
+                        &item.item,
+                        language_server!(item).offset_encoding(),
                         trigger_offset,
                         true,
                         replace_mode,
@@ -267,10 +272,18 @@ impl Completion {
                     // always present here
                     let mut item = item.unwrap().clone();
 
+                    let language_server = language_server!(item);
+                    let offset_encoding = language_server.offset_encoding();
+
+                    let language_server = editor
+                        .language_servers
+                        .get_by_id(item.language_server_id)
+                        .unwrap();
+
                     // resolve item if not yet resolved
                     if !item.resolved {
                         if let Some(resolved) =
-                            Self::resolve_completion_item(doc, item.item.clone())
+                            Self::resolve_completion_item(language_server, item.item.clone())
                         {
                             item.item = resolved;
                         }
@@ -280,7 +293,7 @@ impl Completion {
                     let transaction = item_to_transaction(
                         doc,
                         view.id,
-                        &item,
+                        &item.item,
                         offset_encoding,
                         trigger_offset,
                         false,
@@ -323,11 +336,9 @@ impl Completion {
     }
 
     fn resolve_completion_item(
-        doc: &Document,
+        language_server: &helix_lsp::Client,
         completion_item: lsp::CompletionItem,
     ) -> Option<lsp::CompletionItem> {
-        let language_server = doc.language_server()?;
-
         let future = language_server.resolve_completion_item(completion_item)?;
         let response = helix_lsp::block_on(future);
         match response {
@@ -398,16 +409,10 @@ impl Completion {
             _ => return false,
         };
 
-        let language_server = match doc!(cx.editor).language_server() {
-            Some(language_server) => language_server,
-            None => return false,
-        };
+        let Some(language_server) = cx.editor.language_server_by_id(current_item.language_server_id) else { return false; };
 
         // This method should not block the compositor so we handle the response asynchronously.
-        let future = match language_server.resolve_completion_item(current_item.item.clone()) {
-            Some(future) => future,
-            None => return false,
-        };
+        let Some(future) = language_server.resolve_completion_item(current_item.item.clone()) else { return false; };
 
         cx.callback(
             future,
@@ -422,13 +427,13 @@ impl Completion {
                     .unwrap()
                     .completion
                 {
-                    completion.replace_item(
-                        current_item,
-                        CompletionItem {
-                            item: resolved_item,
-                            resolved: true,
-                        },
-                    );
+                    let resolved_item = CompletionItem {
+                        item: resolved_item,
+                        language_server_id: current_item.language_server_id,
+                        resolved: true,
+                    };
+
+                    completion.replace_item(current_item, resolved_item);
                 }
             },
         );
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index f0989fa8..43b5d1af 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -33,7 +33,7 @@ use std::{mem::take, num::NonZeroUsize, path::PathBuf, rc::Rc, sync::Arc};
 
 use tui::{buffer::Buffer as Surface, text::Span};
 
-use super::statusline;
+use super::{completion::CompletionItem, statusline};
 use super::{document::LineDecoration, lsp::SignatureHelp};
 
 pub struct EditorView {
@@ -650,7 +650,7 @@ impl EditorView {
             .primary()
             .cursor(doc.text().slice(..));
 
-        let diagnostics = doc.diagnostics().iter().filter(|diagnostic| {
+        let diagnostics = doc.shown_diagnostics().filter(|diagnostic| {
             diagnostic.range.start <= cursor && diagnostic.range.end >= cursor
         });
 
@@ -953,20 +953,13 @@ impl EditorView {
         &mut self,
         editor: &mut Editor,
         savepoint: Arc<SavePoint>,
-        items: Vec<helix_lsp::lsp::CompletionItem>,
-        offset_encoding: helix_lsp::OffsetEncoding,
+        items: Vec<CompletionItem>,
         start_offset: usize,
         trigger_offset: usize,
         size: Rect,
     ) -> Option<Rect> {
-        let mut completion = Completion::new(
-            editor,
-            savepoint,
-            items,
-            offset_encoding,
-            start_offset,
-            trigger_offset,
-        );
+        let mut completion =
+            Completion::new(editor, savepoint, items, start_offset, trigger_offset);
 
         if completion.is_empty() {
             // skip if we got no completion results
diff --git a/helix-term/src/ui/mod.rs b/helix-term/src/ui/mod.rs
index 3e9a14b0..ec328ec5 100644
--- a/helix-term/src/ui/mod.rs
+++ b/helix-term/src/ui/mod.rs
@@ -17,7 +17,7 @@ mod text;
 use crate::compositor::{Component, Compositor};
 use crate::filter_picker_entry;
 use crate::job::{self, Callback};
-pub use completion::Completion;
+pub use completion::{Completion, CompletionItem};
 pub use editor::EditorView;
 pub use markdown::Markdown;
 pub use menu::Menu;
@@ -238,6 +238,7 @@ pub mod completers {
     use crate::ui::prompt::Completion;
     use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
     use fuzzy_matcher::FuzzyMatcher;
+    use helix_core::syntax::LanguageServerFeature;
     use helix_view::document::SCRATCH_BUFFER_NAME;
     use helix_view::theme;
     use helix_view::{editor::Config, Editor};
@@ -393,20 +394,11 @@ pub mod completers {
     pub fn lsp_workspace_command(editor: &Editor, input: &str) -> Vec<Completion> {
         let matcher = Matcher::default();
 
-        let (_, doc) = current_ref!(editor);
-
-        let language_server = match doc.language_server() {
-            Some(language_server) => language_server,
-            None => {
-                return vec![];
-            }
-        };
-
-        let options = match &language_server.capabilities().execute_command_provider {
-            Some(options) => options,
-            None => {
-                return vec![];
-            }
+        let Some(options) = doc!(editor)
+            .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
+            .find_map(|ls| ls.capabilities().execute_command_provider.as_ref())
+        else {
+            return vec![];
         };
 
         let mut matches: Vec<_> = options
diff --git a/helix-term/src/ui/statusline.rs b/helix-term/src/ui/statusline.rs
index 88786351..4aa64634 100644
--- a/helix-term/src/ui/statusline.rs
+++ b/helix-term/src/ui/statusline.rs
@@ -197,15 +197,15 @@ where
     );
 }
 
+// TODO think about handling multiple language servers
 fn render_lsp_spinner<F>(context: &mut RenderContext, write: F)
 where
     F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
 {
+    let language_server = context.doc.language_servers().next();
     write(
         context,
-        context
-            .doc
-            .language_server()
+        language_server
             .and_then(|srv| {
                 context
                     .spinners
@@ -225,8 +225,7 @@ where
 {
     let (warnings, errors) = context
         .doc
-        .diagnostics()
-        .iter()
+        .shown_diagnostics()
         .fold((0, 0), |mut counts, diag| {
             use helix_core::diagnostic::Severity;
             match diag.severity {
@@ -266,7 +265,7 @@ where
             .diagnostics
             .values()
             .flatten()
-            .fold((0, 0), |mut counts, diag| {
+            .fold((0, 0), |mut counts, (diag, _)| {
                 match diag.severity {
                     Some(DiagnosticSeverity::WARNING) => counts.0 += 1,
                     Some(DiagnosticSeverity::ERROR) | None => counts.1 += 1,