2eeac10 · helix · git.iko.soy

git.iko.soy/helix

Refactor doc language servers to a HashMap, and the config to use a Vec to retain order

commit2eeac10755e6b88e3d5861dee7e2016a10c01c9f authorPhilipp Mildenberger <philipp@mildenberger.me> dateSun 19 Mar 2023, 23:37 (4 years ago) parentb1199c5

5 files changed+88−83

compare with master

unifiedsplit

helix-core/src/syntax.rs+17−17 helix-lsp/src/lib.rs+13−10 helix-term/src/health.rs+4−4 helix-view/src/document.rs+25−23 helix-view/src/editor.rs+29−29

helix-core/src/syntax.rs+17−17

@@ -112,11 +112,11 @@ pub struct LanguageConfiguration {

112112 // tags_config OnceCell<> https://github.com/tree-sitter/tree-sitter/pull/583

113113 #[serde(

114114 default,

115− skip_serializing_if = "HashMap::is_empty",

115+ skip_serializing_if = "Vec::is_empty",

116116 serialize_with = "serialize_lang_features",

117117 deserialize_with = "deserialize_lang_features"

118118 )]

119− pub language_servers: HashMap<String, LanguageServerFeatures>,

119+ pub language_servers: Vec<LanguageServerFeatures>,

120120 #[serde(skip_serializing_if = "Option::is_none")]

121121 pub indent: Option<IndentationConfiguration>,

122122

@@ -282,19 +282,20 @@ enum LanguageServerFeatureConfiguration {

282282

283283#[derive(Debug, Default)]

284284pub struct LanguageServerFeatures {

285+ pub name: String,

285286 pub only: HashSet<LanguageServerFeature>,

286287 pub excluded: HashSet<LanguageServerFeature>,

287288}

288289

289290impl LanguageServerFeatures {

290291 pub fn has_feature(&self, feature: LanguageServerFeature) -> bool {

291− self.only.is_empty() || self.only.contains(&feature) && !self.excluded.contains(&feature)

292+ (self.only.is_empty() || self.only.contains(&feature)) && !self.excluded.contains(&feature)

292293 }

293294}

294295

295296fn deserialize_lang_features<'de, D>(

296297 deserializer: D,

297−) -> Result<HashMap<String, LanguageServerFeatures>, D::Error>

298+) -> Result<Vec<LanguageServerFeatures>, D::Error>

298299where

299300 D: serde::Deserializer<'de>,

300301{

@@ -302,40 +303,39 @@ where

302303 let res = raw

303304 .into_iter()

304305 .map(|config| match config {

305− LanguageServerFeatureConfiguration::Simple(name) => {

306− (name, LanguageServerFeatures::default())

307− }

306+ LanguageServerFeatureConfiguration::Simple(name) => LanguageServerFeatures {

307+ name,

308+ ..Default::default()

309+ },

308310 LanguageServerFeatureConfiguration::Features {

309311 only_features,

310312 except_features,

311313 name,

312− } => (

314+ } => LanguageServerFeatures {

313315 name,

314− LanguageServerFeatures {

315− only: only_features,

316− excluded: except_features,

317− },

318− ),

316+ only: only_features,

317+ excluded: except_features,

318+ },

319319 })

320320 .collect();

321321 Ok(res)

322322}

323323fn serialize_lang_features<S>(

324− map: &HashMap<String, LanguageServerFeatures>,

324+ map: &Vec<LanguageServerFeatures>,

325325 serializer: S,

326326) -> Result<S::Ok, S::Error>

327327where

328328 S: serde::Serializer,

329329{

330330 let mut serializer = serializer.serialize_seq(Some(map.len()))?;

331− for (name, features) in map {

331+ for features in map {

332332 let features = if features.only.is_empty() && features.excluded.is_empty() {

333− LanguageServerFeatureConfiguration::Simple(name.to_owned())

333+ LanguageServerFeatureConfiguration::Simple(features.name.to_owned())

334334 } else {

335335 LanguageServerFeatureConfiguration::Features {

336336 only_features: features.only.clone(),

337337 except_features: features.excluded.clone(),

338− name: name.to_owned(),

338+ name: features.name.to_owned(),

339339 }

340340 };

341341 serializer.serialize_element(&features)?;

helix-lsp/src/lib.rs+13−10

@@ -12,7 +12,7 @@ pub use lsp_types as lsp;

1212use futures_util::stream::select_all::SelectAll;

1313use helix_core::{

1414 path,

15− syntax::{LanguageConfiguration, LanguageServerConfiguration},

15+ syntax::{LanguageConfiguration, LanguageServerConfiguration, LanguageServerFeatures},

1616};

1717use tokio::sync::mpsc::UnboundedReceiver;

1818

@@ -26,7 +26,7 @@ use thiserror::Error;

2626use tokio_stream::wrappers::UnboundedReceiverStream;

2727

2828pub type Result<T> = core::result::Result<T, Error>;

29−type LanguageServerName = String;

29+pub type LanguageServerName = String;

3030

3131#[derive(Error, Debug)]

3232pub enum Error {

@@ -689,9 +689,9 @@ impl Registry {

689689 ) -> Result<Vec<Arc<Client>>> {

690690 language_config

691691 .language_servers

692− .keys()

693− .filter_map(|name| {

694− #[allow(clippy::map_entry)]

692+ .iter()

693+ .filter_map(|LanguageServerFeatures { name, .. }| {

694+ // #[allow(clippy::map_entry)]

695695 if self.inner.contains_key(name) {

696696 let client = match self.start_client(

697697 name.clone(),

@@ -740,17 +740,20 @@ impl Registry {

740740 doc_path: Option<&std::path::PathBuf>,

741741 root_dirs: &[PathBuf],

742742 enable_snippets: bool,

743− ) -> Result<Vec<Arc<Client>>> {

743+ ) -> Result<HashMap<LanguageServerName, Arc<Client>>> {

744744 language_config

745745 .language_servers

746− .keys()

747− .map(|name| {

746+ .iter()

747+ .map(|LanguageServerFeatures { name, .. }| {

748748 if let Some(clients) = self.inner.get_mut(name) {

749+ // clients.find(

750+

749751 if let Some((_, client)) = clients.iter_mut().enumerate().find(|(i, client)| {

750752 client.try_add_doc(&language_config.roots, root_dirs, doc_path, *i == 0)

751753 }) {

752− return Ok(client.clone());

754+ return Ok((name.to_owned(), client.clone()));

753755 }

756+ // return Ok((name.clone(), clients.clone()));

754757 }

755758 let client = self.start_client(

756759 name.clone(),

@@ -761,7 +764,7 @@ impl Registry {

761764 )?;

762765 let clients = self.inner.entry(name.clone()).or_default();

763766 clients.push(client.clone());

764− Ok(client)

767+ Ok((name.clone(), client))

765768 })

766769 .collect()

767770 }

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.keys().next().and_then(|ls_name| {

197+ let lsp = lang.language_servers.first().and_then(|ls| {

198198 syn_loader_conf

199199 .language_server

200− .get(ls_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.keys().next().and_then(|ls_name| {

274+ lang.language_servers.first().and_then(|ls| {

275275 syn_loader_conf

276276 .language_server

277− .get(ls_name)

277+ .get(&ls.name)

278278 .map(|config| config.command.clone())

279279 }),

280280 )?;

helix-view/src/document.rs+25−23

@@ -180,7 +180,7 @@ pub struct Document {

180180 pub(crate) modified_since_accessed: bool,

181181

182182 diagnostics: Vec<Diagnostic>,

183− language_servers: Vec<Arc<helix_lsp::Client>>,

183+ pub(crate) language_servers: HashMap<LanguageServerName, Arc<Client>>,

184184

185185 diff_handle: Option<DiffHandle>,

186186 version_control_head: Option<Arc<ArcSwap<Box<str>>>>,

@@ -580,7 +580,7 @@ where

580580 *mut_ref = f(mem::take(mut_ref));

581581}

582582

583−use helix_lsp::{lsp, Client, OffsetEncoding};

583+use helix_lsp::{lsp, Client, LanguageServerName, OffsetEncoding};

584584use url::Url;

585585

586586impl Document {

@@ -616,7 +616,7 @@ impl Document {

616616 last_saved_time: SystemTime::now(),

617617 last_saved_revision: 0,

618618 modified_since_accessed: false,

619− language_servers: Vec::new(),

619+ language_servers: HashMap::new(),

620620 diff_handle: None,

621621 config,

622622 version_control_head: None,

@@ -850,7 +850,7 @@ impl Document {

850850 text: text.clone(),

851851 };

852852

853− for language_server in language_servers {

853+ for (_, language_server) in language_servers {

854854 if !language_server.is_initialized() {

855855 return Ok(event);

856856 }

@@ -1006,11 +1006,6 @@ impl Document {

10061006 Ok(())

10071007 }

10081008

1009− /// Set the LSP.

1010− pub fn set_language_servers(&mut self, language_servers: Vec<Arc<helix_lsp::Client>>) {

1011− self.language_servers = language_servers;

1012− }

1013−

10141009 /// Select text within the [`Document`].

10151010 pub fn set_selection(&mut self, view_id: ViewId, selection: Selection) {

10161011 // TODO: use a transaction?

@@ -1437,16 +1432,17 @@ impl Document {

14371432 }

14381433

14391434 pub fn language_servers(&self) -> impl Iterator<Item = &helix_lsp::Client> {

1440− self.language_servers

1441− .iter()

1442− .filter_map(|l| if l.is_initialized() { Some(&**l) } else { None })

1435+ self.language_servers.values().filter_map(|l| {

1436+ if l.is_initialized() {

1437+ Some(&**l)

1438+ } else {

1439+ None

1440+ }

1441+ })

14431442 }

14441443

14451444 pub fn remove_language_server_by_name(&mut self, name: &str) -> Option<Arc<Client>> {

1446− match self.language_servers.iter().position(|l| l.name() == name) {

1447− Some(index) => Some(self.language_servers.remove(index)),

1448− None => None,

1449− }

1445+ self.language_servers.remove(name)

14501446 }

14511447

14521448 // TODO filter also based on LSP capabilities?

@@ -1454,12 +1450,15 @@ impl Document {

14541450 &self,

14551451 feature: LanguageServerFeature,

14561452 ) -> impl Iterator<Item = &helix_lsp::Client> {

1457− self.language_servers().filter(move |server| {

1458− self.language_config()

1459− .and_then(|config| config.language_servers.get(server.name()))

1460− .map_or(false, |server_features| {

1461− server_features.has_feature(feature)

1462− })

1453+ self.language_config().into_iter().flat_map(move |config| {

1454+ config.language_servers.iter().filter_map(move |features| {

1455+ let ls = &**self.language_servers.get(&features.name)?;

1456+ if ls.is_initialized() && features.has_feature(feature) {

1457+ Some(ls)

1458+ } else {

1459+ None

1460+ }

1461+ })

14631462 })

14641463 }

14651464

@@ -1610,7 +1609,10 @@ impl Document {

16101609 .find(|ls| ls.id() == d.language_server_id)

16111610 .and_then(|ls| {

16121611 let config = self.language_config()?;

1613− let features = config.language_servers.get(ls.name())?;

1612+ let features = config

1613+ .language_servers

1614+ .iter()

1615+ .find(|features| features.name == ls.name())?;

16141616 Some(features.has_feature(LanguageServerFeature::Diagnostics))

16151617 })

16161618 == Some(true)

helix-view/src/editor.rs+29−29

@@ -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

@@ -1103,9 +1103,9 @@ impl Editor {

11031103 if !self.config().lsp.enable {

11041104 return None;

11051105 }

1106−

11071106 // if doc doesn't have a URL it's a scratch buffer, ignore it

1108− let doc = self.document(doc_id)?;

1107+ let doc = self.documents.get_mut(&doc_id)?;

1108+ let doc_url = doc.url()?;

11091109 let (lang, path) = (doc.language.clone(), doc.path().cloned());

11101110 let config = doc.config.load();

11111111 let root_dirs = &config.workspace_lsp_roots;

@@ -1124,37 +1124,37 @@ impl Editor {

11241124 .ok()

11251125 });

11261126

1127− let doc = self.document_mut(doc_id)?;

1128− let doc_url = doc.url()?;

1129−

11301127 if let Some(language_servers) = language_servers {

1131− // only spawn new lang servers if the servers aren't the same

1132− // TODO simplify?

1133− let doc_language_servers = doc.language_servers().collect::<Vec<_>>();

1134− let spawn_new_servers = language_servers.len() != doc_language_servers.len()

1135− || language_servers

1136− .iter()

1137− .zip(doc_language_servers.iter())

1138− .any(|(l, dl)| l.id() != dl.id());

1139− if spawn_new_servers {

1140− for doc_language_server in doc_language_servers {

1141− tokio::spawn(doc_language_server.text_document_did_close(doc.identifier()));

1142− }

1128+ let language_id = doc.language_id().map(ToOwned::to_owned).unwrap_or_default();

11431129

1144− let language_id = doc.language_id().map(ToOwned::to_owned).unwrap_or_default();

1130+ // only spawn new language servers if the servers aren't the same

11451131

1146− for language_server in &language_servers {

1147− // TODO: this now races with on_init code if the init happens too quickly

1148− tokio::spawn(language_server.text_document_did_open(

1149− doc_url.clone(),

1150− doc.version(),

1151− doc.text(),

1152− language_id.clone(),

1153− ));

1154− }

1132+ let doc_language_servers_not_in_registry =

1133+ doc.language_servers.iter().filter(|(name, doc_ls)| {

1134+ !language_servers.contains_key(*name)

1135+ || language_servers[*name].id() != doc_ls.id()

1136+ });

11551137

1156− doc.set_language_servers(language_servers);

1138+ for (_, language_server) in doc_language_servers_not_in_registry {

1139+ tokio::spawn(language_server.text_document_did_close(doc.identifier()));

11571140 }

1141+

1142+ let language_servers_not_in_doc = language_servers.iter().filter(|(name, ls)| {

1143+ !doc.language_servers.contains_key(*name)

1144+ || doc.language_servers[*name].id() != ls.id()

1145+ });

1146+

1147+ for (_, language_server) in language_servers_not_in_doc {

1148+ // TODO: this now races with on_init code if the init happens too quickly

1149+ tokio::spawn(language_server.text_document_did_open(

1150+ doc_url.clone(),

1151+ doc.version(),

1152+ doc.text(),

1153+ language_id.clone(),

1154+ ));

1155+ }

1156+

1157+ doc.language_servers = language_servers;

11581158 }

11591159 Some(())

11601160 }