aboutsummaryrefslogtreecommitdiff
path: root/helix-term/src
diff options
context:
space:
mode:
Diffstat (limited to 'helix-term/src')
-rw-r--r--helix-term/src/application.rs145
-rw-r--r--helix-term/src/commands.rs211
-rw-r--r--helix-term/src/commands/lsp.rs850
-rw-r--r--helix-term/src/commands/typed.rs81
-rw-r--r--helix-term/src/health.rs22
-rw-r--r--helix-term/src/ui/completion.rs101
-rw-r--r--helix-term/src/ui/editor.rs17
-rw-r--r--helix-term/src/ui/mod.rs22
-rw-r--r--helix-term/src/ui/statusline.rs11
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,