on master help sign in
Refactored doc.language_servers and doc.language_servers_with_feature to return an iterator and refactor LanguageServerFeature handling to a HashMap (language server name maps to features)

Co-authored-by: Pascal Kuthe <pascal.kuthe@semimod.de>

commit76b5cab52479daf25ffa0af798c1ebcf6a4f0004 authorPhilipp Mildenberger <philipp@mildenberger.me> dateSat 18 Mar 2023, 20:12 (4 years ago) parent0637691
11 files changed+155−138
helix-core/src/syntax.rs+78−19 helix-lsp/src/lib.rs+10−10 helix-term/src/application.rs+4−4 helix-term/src/commands.rs+4−7 helix-term/src/commands/lsp.rs+25−30 helix-term/src/commands/typed.rs+12−12 helix-term/src/health.rs+4−4 helix-term/src/ui/mod.rs+3−5 helix-term/src/ui/statusline.rs+2−3 helix-view/src/document.rs+10−42 helix-view/src/editor.rs+3−2
helix-core/src/syntax.rs+78−19
@@ -16,7 +16,7 @@ use slotmap::{DefaultKey as LayerId, HopSlotMap};
1616use std::{
1717 borrow::Cow,
1818 cell::RefCell,
19− collections::{HashMap, VecDeque},
19+ collections::{HashMap, HashSet, VecDeque},
2020 fmt::{self, Display},
2121 hash::{Hash, Hasher},
2222 mem::{replace, transmute},
@@ -26,7 +26,7 @@ use std::{
2626};
2727
2828use once_cell::sync::{Lazy, OnceCell};
29−use serde::{Deserialize, Serialize};
29+use serde::{ser::SerializeSeq, Deserialize, Serialize};
3030
3131use helix_loader::grammar::{get_language, load_runtime_file};
3232
@@ -110,8 +110,13 @@ pub struct LanguageConfiguration {
110110 #[serde(skip)]
111111 pub(crate) highlight_config: OnceCell<Option<Arc<HighlightConfiguration>>>,
112112 // tags_config OnceCell<> https://github.com/tree-sitter/tree-sitter/pull/583
113− #[serde(default, skip_serializing_if = "Vec::is_empty")]
114− pub language_servers: Vec<LanguageServerFeatureConfiguration>,
113+ #[serde(
114+ default,
115+ skip_serializing_if = "HashMap::is_empty",
116+ serialize_with = "serialize_lang_features",
117+ deserialize_with = "deserialize_lang_features"
118+ )]
119+ pub language_servers: HashMap<String, LanguageServerFeatures>,
115120 #[serde(skip_serializing_if = "Option::is_none")]
116121 pub indent: Option<IndentationConfiguration>,
117122
@@ -211,7 +216,7 @@ impl<'de> Deserialize<'de> for FileType {
211216 }
212217}
213218
214−#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
219+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
215220#[serde(rename_all = "kebab-case")]
216221pub enum LanguageServerFeature {
217222 Format,
@@ -261,18 +266,81 @@ impl Display for LanguageServerFeature {
261266
262267#[derive(Debug, Serialize, Deserialize)]
263268#[serde(untagged, rename_all = "kebab-case", deny_unknown_fields)]
264−pub enum LanguageServerFeatureConfiguration {
269+enum LanguageServerFeatureConfiguration {
265270 #[serde(rename_all = "kebab-case")]
266271 Features {
267− #[serde(default, skip_serializing_if = "Vec::is_empty")]
268− only_features: Vec<LanguageServerFeature>,
269− #[serde(default, skip_serializing_if = "Vec::is_empty")]
270− except_features: Vec<LanguageServerFeature>,
272+ #[serde(default, skip_serializing_if = "HashSet::is_empty")]
273+ only_features: HashSet<LanguageServerFeature>,
274+ #[serde(default, skip_serializing_if = "HashSet::is_empty")]
275+ except_features: HashSet<LanguageServerFeature>,
271276 name: String,
272277 },
273278 Simple(String),
274279}
275280
281+#[derive(Debug, Default)]
282+pub struct LanguageServerFeatures {
283+ pub only: HashSet<LanguageServerFeature>,
284+ pub excluded: HashSet<LanguageServerFeature>,
285+}
286+
287+impl LanguageServerFeatures {
288+ pub fn has_feature(&self, feature: LanguageServerFeature) -> bool {
289+ self.only.is_empty() || self.only.contains(&feature) && !self.excluded.contains(&feature)
290+ }
291+}
292+
293+fn deserialize_lang_features<'de, D>(
294+ deserializer: D,
295+) -> Result<HashMap<String, LanguageServerFeatures>, D::Error>
296+where
297+ D: serde::Deserializer<'de>,
298+{
299+ let raw: Vec<LanguageServerFeatureConfiguration> = Deserialize::deserialize(deserializer)?;
300+ let res = raw
301+ .into_iter()
302+ .map(|config| match config {
303+ LanguageServerFeatureConfiguration::Simple(name) => {
304+ (name, LanguageServerFeatures::default())
305+ }
306+ LanguageServerFeatureConfiguration::Features {
307+ only_features,
308+ except_features,
309+ name,
310+ } => (
311+ name,
312+ LanguageServerFeatures {
313+ only: only_features,
314+ excluded: except_features,
315+ },
316+ ),
317+ })
318+ .collect();
319+ Ok(res)
320+}
321+fn serialize_lang_features<S>(
322+ map: &HashMap<String, LanguageServerFeatures>,
323+ serializer: S,
324+) -> Result<S::Ok, S::Error>
325+where
326+ S: serde::Serializer,
327+{
328+ let mut serializer = serializer.serialize_seq(Some(map.len()))?;
329+ for (name, features) in map {
330+ let features = if features.only.is_empty() && features.excluded.is_empty() {
331+ LanguageServerFeatureConfiguration::Simple(name.to_owned())
332+ } else {
333+ LanguageServerFeatureConfiguration::Features {
334+ only_features: features.only.clone(),
335+ except_features: features.excluded.clone(),
336+ name: name.to_owned(),
337+ }
338+ };
339+ serializer.serialize_element(&features)?;
340+ }
341+ serializer.end()
342+}
343+
276344#[derive(Debug, Serialize, Deserialize)]
277345#[serde(rename_all = "kebab-case")]
278346pub struct LanguageServerConfiguration {
@@ -650,15 +718,6 @@ pub struct SoftWrap {
650718 pub wrap_at_text_width: Option<bool>,
651719}
652720
653−impl LanguageServerFeatureConfiguration {
654− pub fn name(&self) -> &String {
655− match self {
656− LanguageServerFeatureConfiguration::Simple(name) => name,
657− LanguageServerFeatureConfiguration::Features { name, .. } => name,
658− }
659− }
660−}
661−
662721// Expose loader as Lazy<> global since it's always static?
663722
664723#[derive(Debug)]
helix-lsp/src/lib.rs+10−10
@@ -689,12 +689,10 @@ impl Registry {
689689 ) -> Result<Vec<Arc<Client>>> {
690690 language_config
691691 .language_servers
692− .iter()
693− .filter_map(|config| {
694− let name = config.name().clone();
695−
692+ .keys()
693+ .filter_map(|name| {
696694 #[allow(clippy::map_entry)]
697− if self.inner.contains_key(&name) {
695+ if self.inner.contains_key(name) {
698696 let client = match self.start_client(
699697 name.clone(),
700698 language_config,
@@ -705,7 +703,10 @@ impl Registry {
705703 Ok(client) => client,
706704 error => return Some(error),
707705 };
708− let old_clients = self.inner.insert(name, vec![client.clone()]).unwrap();
706+ let old_clients = self
707+ .inner
708+ .insert(name.clone(), vec![client.clone()])
709+ .unwrap();
709710
710711 // TODO what if there are different language servers for different workspaces,
711712 // I think the language servers will be stopped without being restarted, which is not intended
@@ -742,9 +743,8 @@ impl Registry {
742743 ) -> Result<Vec<Arc<Client>>> {
743744 language_config
744745 .language_servers
745− .iter()
746− .map(|features| {
747− let name = features.name();
746+ .keys()
747+ .map(|name| {
748748 if let Some(clients) = self.inner.get_mut(name) {
749749 if let Some((_, client)) = clients.iter_mut().enumerate().find(|(i, client)| {
750750 client.try_add_doc(&language_config.roots, root_dirs, doc_path, *i == 0)
@@ -759,7 +759,7 @@ impl Registry {
759759 root_dirs,
760760 enable_snippets,
761761 )?;
762− let clients = self.inner.entry(features.name().clone()).or_default();
762+ let clients = self.inner.entry(name.clone()).or_default();
763763 clients.push(client.clone());
764764 Ok(client)
765765 })
helix-term/src/application.rs+4−4
@@ -699,9 +699,10 @@ impl Application {
699699 tokio::spawn(language_server.did_change_configuration(config.clone()));
700700 }
701701
702− let docs = self.editor.documents().filter(|doc| {
703− doc.language_servers().iter().any(|l| l.id() == server_id)
704− });
702+ let docs = self
703+ .editor
704+ .documents()
705+ .filter(|doc| doc.language_servers().any(|l| l.id() == server_id));
705706
706707 // trigger textDocument/didOpen for docs that are already open
707708 for doc in docs {
@@ -970,7 +971,6 @@ impl Application {
970971 .filter_map(|doc| {
971972 if doc
972973 .language_servers()
973− .iter()
974974 .any(|server| server.id() == server_id)
975975 {
976976 doc.clear_diagnostics(server_id);
helix-term/src/commands.rs+4−7
@@ -3235,7 +3235,6 @@ pub mod insert {
32353235 let doc = doc_mut!(cx.editor);
32363236 let trigger_completion = doc
32373237 .language_servers_with_feature(LanguageServerFeature::Completion)
3238− .iter()
32393238 .any(|ls| {
32403239 let capabilities = ls.capabilities();
32413240
@@ -3264,7 +3263,6 @@ pub mod insert {
32643263 // TODO support multiple language servers (not just the first that is found)
32653264 let future = doc
32663265 .language_servers_with_feature(LanguageServerFeature::SignatureHelp)
3267− .iter()
32683266 .find_map(|ls| {
32693267 let capabilities = ls.capabilities();
32703268
@@ -4067,10 +4065,8 @@ fn format_selections(cx: &mut Context) {
40674065 .set_error("format_selections only supports a single selection for now");
40684066 return;
40694067 }
4070−
4071− let (future, offset_encoding) = match doc
4068+ let future_offset_encoding = doc
40724069 .language_servers_with_feature(LanguageServerFeature::Format)
4073− .iter()
40744070 .find_map(|language_server| {
40754071 let offset_encoding = language_server.offset_encoding();
40764072 let ranges: Vec<lsp::Range> = doc
@@ -4091,7 +4087,9 @@ fn format_selections(cx: &mut Context) {
40914087 None,
40924088 )?;
40934089 Some((future, offset_encoding))
4094− }) {
4090+ });
4091+
4092+ let (future, offset_encoding) = match future_offset_encoding {
40954093 Some(future_offset_encoding) => future_offset_encoding,
40964094 None => {
40974095 cx.editor
@@ -4247,7 +4245,6 @@ pub fn completion(cx: &mut Context) {
42474245
42484246 let mut futures: FuturesUnordered<_> = doc
42494247 .language_servers_with_feature(LanguageServerFeature::Completion)
4250− .iter()
42514248 // TODO this should probably already been filtered in something like "language_servers_with_feature"
42524249 .filter_map(|language_server| {
42534250 let language_server_id = language_server.id();
helix-term/src/commands/lsp.rs+25−30
@@ -353,7 +353,6 @@ pub fn symbol_picker(cx: &mut Context) {
353353
354354 let mut futures: FuturesUnordered<_> = doc
355355 .language_servers_with_feature(LanguageServerFeature::DocumentSymbols)
356− .iter()
357356 .filter_map(|ls| {
358357 let request = ls.document_symbols(doc.identifier())?;
359358 Some((request, ls.offset_encoding(), doc.identifier()))
@@ -420,7 +419,6 @@ pub fn workspace_symbol_picker(cx: &mut Context) {
420419 let doc = doc!(editor);
421420 let mut futures: FuturesUnordered<_> = doc
422421 .language_servers_with_feature(LanguageServerFeature::WorkspaceSymbols)
423− .iter()
424422 .filter_map(|ls| Some((ls.workspace_symbols(pattern.clone())?, ls.offset_encoding())))
425423 .map(|(request, offset_encoding)| async move {
426424 let json = request.await?;
@@ -581,7 +579,6 @@ pub fn code_action(cx: &mut Context) {
581579
582580 let mut futures: FuturesUnordered<_> = doc
583581 .language_servers_with_feature(LanguageServerFeature::CodeAction)
584− .iter()
585582 // TODO this should probably already been filtered in something like "language_servers_with_feature"
586583 .filter_map(|language_server| {
587584 let offset_encoding = language_server.offset_encoding();
@@ -1034,15 +1031,15 @@ fn to_locations(definitions: Option<lsp::GotoDefinitionResponse>) -> Vec<lsp::Lo
10341031// TODO find a way to reduce boilerplate of all the goto functions, without unnecessary complexity...
10351032pub fn goto_declaration(cx: &mut Context) {
10361033 let (view, doc) = current!(cx.editor);
1037− let (future, offset_encoding) = match doc
1034+ let future_offset_encoding = doc
10381035 .language_servers_with_feature(LanguageServerFeature::GotoDeclaration)
1039− .iter()
10401036 .find_map(|language_server| {
10411037 let offset_encoding = language_server.offset_encoding();
10421038 let pos = doc.position(view.id, offset_encoding);
10431039 let future = language_server.goto_declaration(doc.identifier(), pos, None)?;
10441040 Some((future, offset_encoding))
1045− }) {
1041+ });
1042+ let (future, offset_encoding) = match future_offset_encoding {
10461043 Some(future_offset_encoding) => future_offset_encoding,
10471044 None => {
10481045 cx.editor
@@ -1062,15 +1059,15 @@ pub fn goto_declaration(cx: &mut Context) {
10621059
10631060pub fn goto_definition(cx: &mut Context) {
10641061 let (view, doc) = current!(cx.editor);
1065− let (future, offset_encoding) = match doc
1062+ let future_offset_encoding = doc
10661063 .language_servers_with_feature(LanguageServerFeature::GotoDefinition)
1067− .iter()
10681064 .find_map(|language_server| {
10691065 let offset_encoding = language_server.offset_encoding();
10701066 let pos = doc.position(view.id, offset_encoding);
10711067 let future = language_server.goto_definition(doc.identifier(), pos, None)?;
10721068 Some((future, offset_encoding))
1073− }) {
1069+ });
1070+ let (future, offset_encoding) = match future_offset_encoding {
10741071 Some(future_offset_encoding) => future_offset_encoding,
10751072 None => {
10761073 cx.editor
@@ -1090,15 +1087,15 @@ pub fn goto_definition(cx: &mut Context) {
10901087
10911088pub fn goto_type_definition(cx: &mut Context) {
10921089 let (view, doc) = current!(cx.editor);
1093− let (future, offset_encoding) = match doc
1090+ let future_offset_encoding = doc
10941091 .language_servers_with_feature(LanguageServerFeature::GotoTypeDefinition)
1095− .iter()
10961092 .find_map(|language_server| {
10971093 let offset_encoding = language_server.offset_encoding();
10981094 let pos = doc.position(view.id, offset_encoding);
10991095 let future = language_server.goto_type_definition(doc.identifier(), pos, None)?;
11001096 Some((future, offset_encoding))
1101− }) {
1097+ });
1098+ let (future, offset_encoding) = match future_offset_encoding {
11021099 Some(future_offset_encoding) => future_offset_encoding,
11031100 None => {
11041101 cx.editor
@@ -1118,15 +1115,15 @@ pub fn goto_type_definition(cx: &mut Context) {
11181115
11191116pub fn goto_implementation(cx: &mut Context) {
11201117 let (view, doc) = current!(cx.editor);
1121− let (future, offset_encoding) = match doc
1118+ let future_offset_encoding = doc
11221119 .language_servers_with_feature(LanguageServerFeature::GotoImplementation)
1123− .iter()
11241120 .find_map(|language_server| {
11251121 let offset_encoding = language_server.offset_encoding();
11261122 let pos = doc.position(view.id, offset_encoding);
11271123 let future = language_server.goto_implementation(doc.identifier(), pos, None)?;
11281124 Some((future, offset_encoding))
1129− }) {
1125+ });
1126+ let (future, offset_encoding) = match future_offset_encoding {
11301127 Some(future_offset_encoding) => future_offset_encoding,
11311128 None => {
11321129 cx.editor
@@ -1147,9 +1144,8 @@ pub fn goto_implementation(cx: &mut Context) {
11471144pub fn goto_reference(cx: &mut Context) {
11481145 let config = cx.editor.config();
11491146 let (view, doc) = current!(cx.editor);
1150− let (future, offset_encoding) = match doc
1147+ let future_offset_encoding = doc
11511148 .language_servers_with_feature(LanguageServerFeature::GotoReference)
1152− .iter()
11531149 .find_map(|language_server| {
11541150 let offset_encoding = language_server.offset_encoding();
11551151 let pos = doc.position(view.id, offset_encoding);
@@ -1160,7 +1156,8 @@ pub fn goto_reference(cx: &mut Context) {
11601156 None,
11611157 )?;
11621158 Some((future, offset_encoding))
1163− }) {
1159+ });
1160+ let (future, offset_encoding) = match future_offset_encoding {
11641161 Some(future_offset_encoding) => future_offset_encoding,
11651162 None => {
11661163 cx.editor
@@ -1192,13 +1189,14 @@ pub fn signature_help_impl(cx: &mut Context, invoked: SignatureHelpInvoked) {
11921189 let (view, doc) = current!(cx.editor);
11931190
11941191 // TODO merge multiple language server signature help into one instead of just taking the first language server that supports it
1195− let future = match doc
1192+ let future = doc
11961193 .language_servers_with_feature(LanguageServerFeature::SignatureHelp)
1197− .iter()
11981194 .find_map(|language_server| {
11991195 let pos = doc.position(view.id, language_server.offset_encoding());
12001196 language_server.text_document_signature_help(doc.identifier(), pos, None)
1201− }) {
1197+ });
1198+
1199+ let future = match future {
12021200 Some(future) => future.boxed(),
12031201 None => {
12041202 // Do not show the message if signature help was invoked
@@ -1328,7 +1326,6 @@ pub fn hover(cx: &mut Context) {
13281326 // TODO: factor out a doc.position_identifier() that returns lsp::TextDocumentPositionIdentifier
13291327 let request = doc
13301328 .language_servers_with_feature(LanguageServerFeature::Hover)
1331− .iter()
13321329 .find_map(|language_server| {
13331330 let pos = doc.position(view.id, language_server.offset_encoding());
13341331 language_server.text_document_hover(doc.identifier(), pos, None)
@@ -1436,7 +1433,6 @@ pub fn rename_symbol(cx: &mut Context) {
14361433 let (view, doc) = current!(cx.editor);
14371434 let request = doc
14381435 .language_servers_with_feature(LanguageServerFeature::RenameSymbol)
1439− .iter()
14401436 .find_map(|language_server| {
14411437 if let Some(language_server_id) = language_server_id {
14421438 if language_server.id() != language_server_id {
@@ -1475,7 +1471,6 @@ pub fn rename_symbol(cx: &mut Context) {
14751471
14761472 let prepare_rename_request = doc
14771473 .language_servers_with_feature(LanguageServerFeature::RenameSymbol)
1478− .iter()
14791474 .find_map(|language_server| {
14801475 let offset_encoding = language_server.offset_encoding();
14811476 let pos = doc.position(view.id, offset_encoding);
@@ -1516,17 +1511,17 @@ pub fn rename_symbol(cx: &mut Context) {
15161511
15171512pub fn select_references_to_symbol_under_cursor(cx: &mut Context) {
15181513 let (view, doc) = current!(cx.editor);
1519− let (future, offset_encoding) = match doc
1514+ let future_offset_encoding = doc
15201515 .language_servers_with_feature(LanguageServerFeature::DocumentHighlight)
1521− .iter()
15221516 .find_map(|language_server| {
15231517 let offset_encoding = language_server.offset_encoding();
15241518 let pos = doc.position(view.id, offset_encoding);
15251519 let future =
15261520 language_server.text_document_document_highlight(doc.identifier(), pos, None)?;
15271521 Some((future, offset_encoding))
1528− }) {
1529− Some(future) => future,
1522+ });
1523+ let (future, offset_encoding) = match future_offset_encoding {
1524+ Some(future_offset_encoding) => future_offset_encoding,
15301525 None => {
15311526 cx.editor
15321527 .set_error("No language server supports document-highlight");
@@ -1587,8 +1582,8 @@ fn compute_inlay_hints_for_view(
15871582 let view_id = view.id;
15881583 let doc_id = view.doc;
15891584
1590− let language_servers = doc.language_servers_with_feature(LanguageServerFeature::InlayHints);
1591− let language_server = language_servers.iter().find(|language_server| {
1585+ let mut language_servers = doc.language_servers_with_feature(LanguageServerFeature::InlayHints);
1586+ let language_server = language_servers.find(|language_server| {
15921587 matches!(
15931588 language_server.capabilities().inlay_hint_provider,
15941589 Some(
helix-term/src/commands/typed.rs+12−12
@@ -1330,14 +1330,16 @@ fn lsp_workspace_command(
13301330 return Ok(());
13311331 }
13321332 let doc = doc!(cx.editor);
1333− let language_servers =
1334− doc.language_servers_with_feature(LanguageServerFeature::WorkspaceCommand);
1335− let (language_server_id, options) = match language_servers.iter().find_map(|ls| {
1336− ls.capabilities()
1337− .execute_command_provider
1338− .as_ref()
1339− .map(|options| (ls.id(), options))
1340− }) {
1333+ let id_options = doc
1334+ .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
1335+ .find_map(|ls| {
1336+ ls.capabilities()
1337+ .execute_command_provider
1338+ .as_ref()
1339+ .map(|options| (ls.id(), options))
1340+ });
1341+
1342+ let (language_server_id, options) = match id_options {
13411343 Some(id_options) => id_options,
13421344 None => {
13431345 cx.editor.set_status(
@@ -1346,6 +1348,7 @@ fn lsp_workspace_command(
13461348 return Ok(());
13471349 }
13481350 };
1351+
13491352 if args.is_empty() {
13501353 let commands = options
13511354 .commands
@@ -1445,7 +1448,6 @@ fn lsp_stop(
14451448 // I'm not sure if this is really what we want
14461449 let ls_shutdown_names = doc
14471450 .language_servers()
1448− .iter()
14491451 .map(|ls| ls.name())
14501452 .collect::<Vec<_>>();
14511453
@@ -1459,7 +1461,6 @@ fn lsp_stop(
14591461 .filter_map(|doc| {
14601462 let doc_active_ls_ids: Vec<_> = doc
14611463 .language_servers()
1462− .iter()
14631464 .filter(|ls| !ls_shutdown_names.contains(&ls.name()))
14641465 .map(|ls| ls.id())
14651466 .collect();
@@ -1472,7 +1473,7 @@ fn lsp_stop(
14721473 .map(Clone::clone)
14731474 .collect();
14741475
1475− if active_clients.len() != doc.language_servers().len() {
1476+ if active_clients.len() != doc.language_servers().count() {
14761477 Some((doc.id(), active_clients))
14771478 } else {
14781479 None
@@ -1485,7 +1486,6 @@ fn lsp_stop(
14851486
14861487 let stopped_clients: Vec<_> = doc
14871488 .language_servers()
1488− .iter()
14891489 .filter(|ls| {
14901490 !active_clients
14911491 .iter()
helix-term/src/health.rs+4−4
@@ -194,10 +194,10 @@ pub fn languages_all() -> std::io::Result<()> {
194194
195195 // TODO multiple language servers (check binary for each supported language server, not just the first)
196196
197− let lsp = lang.language_servers.first().and_then(|lsp| {
197+ let lsp = lang.language_servers.keys().next().and_then(|ls_name| {
198198 syn_loader_conf
199199 .language_server
200− .get(lsp.name())
200+ .get(ls_name)
201201 .map(|config| config.command.clone())
202202 });
203203 check_binary(lsp);
@@ -271,10 +271,10 @@ pub fn language(lang_str: String) -> std::io::Result<()> {
271271 // TODO multiple language servers
272272 probe_protocol(
273273 "language server",
274− lang.language_servers.first().and_then(|lsp| {
274+ lang.language_servers.keys().next().and_then(|ls_name| {
275275 syn_loader_conf
276276 .language_server
277− .get(lsp.name())
277+ .get(ls_name)
278278 .map(|config| config.command.clone())
279279 }),
280280 )?;
helix-term/src/ui/mod.rs+3−5
@@ -394,13 +394,11 @@ pub mod completers {
394394 pub fn lsp_workspace_command(editor: &Editor, input: &str) -> Vec<Completion> {
395395 let matcher = Matcher::default();
396396
397− let language_servers =
398− doc!(editor).language_servers_with_feature(LanguageServerFeature::WorkspaceCommand);
399− let options = match language_servers
400− .into_iter()
397+ let options = match doc!(editor)
398+ .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
401399 .find_map(|ls| ls.capabilities().execute_command_provider.as_ref())
402400 {
403− Some(id_options) => id_options,
401+ Some(options) => options,
404402 None => {
405403 return vec![];
406404 }
helix-term/src/ui/statusline.rs+2−3
@@ -202,11 +202,10 @@ fn render_lsp_spinner<F>(context: &mut RenderContext, write: F)
202202where
203203 F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
204204{
205− let language_servers = context.doc.language_servers();
205+ let language_server = context.doc.language_servers().next();
206206 write(
207207 context,
208− language_servers
209− .first()
208+ language_server
210209 .and_then(|srv| {
211210 context
212211 .spinners
helix-view/src/document.rs+10−42
@@ -6,7 +6,7 @@ use futures_util::FutureExt;
66use helix_core::auto_pairs::AutoPairs;
77use helix_core::doc_formatter::TextFormat;
88use helix_core::encoding::Encoding;
9−use helix_core::syntax::{Highlight, LanguageServerFeature, LanguageServerFeatureConfiguration};
9+use helix_core::syntax::{Highlight, LanguageServerFeature};
1010use helix_core::text_annotations::{InlineAnnotation, TextAnnotations};
1111use helix_core::Range;
1212use helix_vcs::{DiffHandle, DiffProviderRegistry};
@@ -734,7 +734,6 @@ impl Document {
734734 // finds first language server that supports formatting and then formats
735735 let (offset_encoding, request) = self
736736 .language_servers_with_feature(LanguageServerFeature::Format)
737− .iter()
738737 .find_map(|language_server| {
739738 let offset_encoding = language_server.offset_encoding();
740739 let request = language_server.text_document_formatting(
@@ -1437,54 +1436,24 @@ impl Document {
14371436 self.version
14381437 }
14391438
1440− /// Language servers that have been initialized.
1441− pub fn language_servers(&self) -> Vec<&helix_lsp::Client> {
1439+ pub fn language_servers(&self) -> impl Iterator<Item = &helix_lsp::Client> {
14421440 self.language_servers
14431441 .iter()
14441442 .filter_map(|l| if l.is_initialized() { Some(&**l) } else { None })
1445− .collect()
14461443 }
14471444
14481445 // TODO filter also based on LSP capabilities?
14491446 pub fn language_servers_with_feature(
14501447 &self,
14511448 feature: LanguageServerFeature,
1452− ) -> Vec<&helix_lsp::Client> {
1453− let language_servers = self.language_servers();
1454−
1455− let language_config = match self.language_config() {
1456− Some(language_config) => language_config,
1457− None => return Vec::new(),
1458− };
1459−
1460− // O(n^2) but since language_servers will be of very small length,
1461− // I don't see the necessity to optimize
1462− language_config
1463− .language_servers
1464− .iter()
1465− .filter_map(|c| match c {
1466− LanguageServerFeatureConfiguration::Simple(name) => language_servers
1467− .iter()
1468− .find(|ls| ls.name() == name)
1469− .copied(),
1470− LanguageServerFeatureConfiguration::Features {
1471− only_features,
1472− except_features,
1473− name,
1474− } => {
1475− if (only_features.is_empty() || only_features.contains(&feature))
1476− && !except_features.contains(&feature)
1477− {
1478− language_servers
1479− .iter()
1480− .find(|ls| ls.name() == name)
1481− .copied()
1482− } else {
1483− None
1484− }
1485− }
1486− })
1487− .collect()
1449+ ) -> impl Iterator<Item = &helix_lsp::Client> {
1450+ self.language_servers().filter(move |server| {
1451+ self.language_config()
1452+ .and_then(|config| config.language_servers.get(server.name()))
1453+ .map_or(false, |server_features| {
1454+ server_features.has_feature(feature)
1455+ })
1456+ })
14881457 }
14891458
14901459 pub fn diff_handle(&self) -> Option<&DiffHandle> {
@@ -1610,7 +1579,6 @@ impl Document {
16101579 pub fn shown_diagnostics(&self) -> impl Iterator<Item = &Diagnostic> + DoubleEndedIterator {
16111580 let ls_ids: HashSet<_> = self
16121581 .language_servers_with_feature(LanguageServerFeature::Diagnostics)
1613− .iter()
16141582 .map(|ls| ls.id())
16151583 .collect();
16161584 self.diagnostics
helix-view/src/editor.rs+3−2
@@ -689,7 +689,7 @@ pub struct WhitespaceCharacters {
689689impl Default for WhitespaceCharacters {
690690 fn default() -> Self {
691691 Self {
692− space: '·', // U+00B7
692+ space: '·', // U+00B7
693693 nbsp: '⍽', // U+237D
694694 tab: '→', // U+2192
695695 newline: '⏎', // U+23CE
@@ -1129,7 +1129,8 @@ impl Editor {
11291129
11301130 if let Some(language_servers) = language_servers {
11311131 // only spawn new lang servers if the servers aren't the same
1132− let doc_language_servers = doc.language_servers();
1132+ // TODO simplify?
1133+ let doc_language_servers = doc.language_servers().collect::<Vec<_>>();
11331134 let spawn_new_servers = language_servers.len() != doc_language_servers.len()
11341135 || language_servers
11351136 .iter()