Refactored Option<Vec> to Vec and some cleanup

Philipp-M · Philipp-M · commit f2ee673fae04 · 2022-05-22T12:45:27.000+02:00
diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs
@@ -88,8 +88,8 @@ pub struct LanguageConfiguration {
     #[serde(skip)]
     pub(crate) highlight_config: OnceCell<Option<Arc<HighlightConfiguration>>>,
     // tags_config OnceCell<> https://github.com/tree-sitter/tree-sitter/pull/583
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub language_servers: Option<Vec<LanguageServerConfiguration>>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub language_servers: Vec<LanguageServerConfiguration>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub indent: Option<IndentationConfiguration>,
 
diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs
@@ -326,10 +326,11 @@ impl Registry {
     }
 
     pub fn get(&mut self, language_config: &LanguageConfiguration) -> Result<Vec<Arc<Client>>> {
-        let configs = match &language_config.language_servers {
-            Some(configs) => configs,
-            None => return Err(Error::LspNotDefined),
-        };
+        let configs = &language_config.language_servers;
+
+        if configs.is_empty() {
+            return Err(Error::LspNotDefined);
+        }
 
         match self.inner.entry(language_config.scope.clone()) {
             Entry::Occupied(entry) => Ok(entry.get().iter().map(|(_, c)| c.clone()).collect()),
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
@@ -433,9 +433,7 @@ impl Application {
                         }
 
                         let docs = self.editor.documents().filter(|doc| {
-                            doc.language_servers()
-                                .map(|ls| ls.iter().any(|l| l.id() == server_id))
-                                == Some(true)
+                            doc.language_servers().iter().any(|l| l.id() == server_id)
                         });
 
                         // trigger textDocument/didOpen for docs that are already open
@@ -458,8 +456,9 @@ impl Application {
                         if let Some(doc) = doc {
                             let language_server = doc
                                 .language_servers()
-                                .as_ref()
-                                .and_then(|ls| ls.iter().find(|l| l.id() == server_id).map(|l| *l))
+                                .iter()
+                                .find(|l| l.id() == server_id)
+                                .map(|l| *l)
                                 .unwrap();
                             let lang_conf = doc.language_config();
                             let text = doc.text();
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
@@ -2668,12 +2668,7 @@ pub mod insert {
         use helix_lsp::lsp;
         // if ch matches completion char, trigger completion
         let doc = doc_mut!(cx.editor);
-        let language_servers = match doc.language_servers() {
-            Some(language_servers) => language_servers,
-            None => return,
-        };
-
-        let trigger_completion = language_servers.iter().any(|language_server| {
+        let trigger_completion = doc.language_servers().iter().any(|language_server| {
             let capabilities = language_server.capabilities();
 
             // TODO: what if trigger is multiple chars long
@@ -2696,12 +2691,7 @@ pub mod insert {
         use helix_lsp::lsp;
         // if ch matches signature_help char, trigger
         let doc = doc_mut!(cx.editor);
-        let language_servers = match doc.language_servers() {
-            Some(language_servers) => language_servers,
-            None => return,
-        };
-
-        let is_trigger = language_servers.iter().any(|language_server| {
+        let is_trigger = doc.language_servers().iter().any(|language_server| {
             let capabilities = language_server.capabilities();
 
             match capabilities {
@@ -3434,11 +3424,8 @@ fn format_selections(cx: &mut Context) {
     // via lsp if available
     // else via tree-sitter indentation calculations
 
-    let language_server = match doc.language_servers() {
-        Some(language_servers) => match language_servers.first() {
-            Some(language_server) => *language_server,
-            None => return,
-        },
+    let language_server = match doc.language_servers().first() {
+        Some(language_server) => *language_server,
         None => return,
     };
 
@@ -3576,11 +3563,8 @@ pub fn completion(cx: &mut Context) {
 
     // TODO merge completion items of multiple language servers,
     // instead of taking the first language server for completion
-    let language_server = match doc.language_servers() {
-        Some(language_servers) => match language_servers.first() {
-            Some(language_server) => *language_server,
-            None => return,
-        },
+    let language_server = match doc.language_servers().first() {
+        Some(language_server) => *language_server,
         None => return,
     };
 
diff --git a/helix-term/src/commands/lsp.rs b/helix-term/src/commands/lsp.rs
@@ -20,7 +20,7 @@ use std::borrow::Cow;
 #[macro_export]
 macro_rules! language_server {
     ($editor:expr, $doc:expr) => {
-        match $doc.language_servers().as_ref().and_then(|ls| ls.first()) {
+        match $doc.language_servers().first() {
             Some(language_server) => &**language_server,
             None => {
                 $editor.set_status("Language server not active for current buffer");
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
@@ -227,7 +227,7 @@ fn write_impl(
     if path.is_some() {
         let id = doc.id();
         doc.detect_language(cx.editor.syn_loader.clone());
-        let _ = cx.editor.refresh_language_server(id);
+        let _ = cx.editor.refresh_language_servers(id);
     }
     Ok(())
 }
@@ -1007,7 +1007,7 @@ fn language(
     doc.set_language_by_language_id(&args[0], cx.editor.syn_loader.clone());
 
     let id = doc.id();
-    cx.editor.refresh_language_server(id);
+    cx.editor.refresh_language_servers(id);
     Ok(())
 }
 
diff --git a/helix-term/src/health.rs b/helix-term/src/health.rs
@@ -144,11 +144,7 @@ pub fn languages_all() -> std::io::Result<()> {
         column(&lang.language_id, Color::Reset);
 
         // TODO multiple language servers
-        let lsp = lang
-            .language_servers
-            .as_ref()
-            .and_then(|lsps| lsps.first())
-            .map(|lsp| lsp.command.to_string());
+        let lsp = lang.language_servers.first().map(|lsp| lsp.command.clone());
         check_binary(lsp);
 
         let dap = lang.debugger.as_ref().map(|dap| dap.command.to_string());
@@ -220,11 +216,7 @@ pub fn language(lang_str: String) -> std::io::Result<()> {
     // TODO multiple language servers
     probe_protocol(
         "language server",
-        lang
-            .language_servers
-            .as_ref()
-            .and_then(|lsps| lsps.first())
-            .map(|lsp| lsp.command.to_string()),
+        lang.language_servers.first().map(|lsp| lsp.command.clone()),
     )?;
 
     probe_protocol(
diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
@@ -225,7 +225,7 @@ impl Completion {
         completion_item: lsp::CompletionItem,
     ) -> Option<CompletionItem> {
         // TODO support multiple language servers instead of taking the first language server
-        let language_server = doc.language_servers().as_ref().and_then(|ls| ls.first().map(|l| *l))?;
+        let language_server = doc.language_servers().first().map(|l| *l)?;
         let completion_resolve_provider = language_server
             .capabilities()
             .completion_provider
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
@@ -652,15 +652,14 @@ impl EditorView {
             Mode::Select => "SEL",
             Mode::Normal => "NOR",
         };
+        // TODO handle multiple language servers
         let progress = doc
             .language_servers()
-            .and_then(|ls| {
-                // TODO handle multiple language servers
-                ls.first().and_then(|srv| {
-                    self.spinners
-                        .get(srv.id())
-                        .and_then(|spinner| spinner.frame())
-                })
+            .first()
+            .and_then(|srv| {
+                self.spinners
+                    .get(srv.id())
+                    .and_then(|spinner| spinner.frame())
             })
             .unwrap_or("");
 
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
@@ -119,7 +119,7 @@ pub struct Document {
     pub(crate) modified_since_accessed: bool,
 
     diagnostics: Vec<Diagnostic>,
-    language_servers: Option<Vec<Arc<helix_lsp::Client>>>,
+    language_servers: Vec<Arc<helix_lsp::Client>>,
 }
 
 use std::{fmt, mem};
@@ -359,7 +359,7 @@ impl Document {
             savepoint: None,
             last_saved_revision: 0,
             modified_since_accessed: false,
-            language_servers: None,
+            language_servers: Vec::new(),
         }
     }
 
@@ -407,22 +407,22 @@ impl Document {
     /// If supported, returns the changes that should be applied to this document in order
     /// to format it nicely.
     pub fn format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {
-        let language_servers = self.language_servers()?;
         let text = self.text.clone();
         // finds first language server that supports formatting and then formats
-        let (offset_encoding, request) = language_servers.iter().find_map(|language_server| {
-            let offset_encoding = language_server.offset_encoding();
-            let request = language_server.text_document_formatting(
-                self.identifier(),
-                lsp::FormattingOptions {
-                    tab_size: self.tab_width() as u32,
-                    insert_spaces: matches!(self.indent_style, IndentStyle::Spaces(_)),
-                    ..Default::default()
-                },
-                None,
-            )?;
-            Some((offset_encoding, request))
-        })?;
+        let (offset_encoding, request) =
+            self.language_servers().iter().find_map(|language_server| {
+                let offset_encoding = language_server.offset_encoding();
+                let request = language_server.text_document_formatting(
+                    self.identifier(),
+                    lsp::FormattingOptions {
+                        tab_size: self.tab_width() as u32,
+                        insert_spaces: matches!(self.indent_style, IndentStyle::Spaces(_)),
+                        ..Default::default()
+                    },
+                    None,
+                )?;
+                Some((offset_encoding, request))
+            })?;
 
         let fut = async move {
             let edits = request.await.unwrap_or_else(|e| {
@@ -501,16 +501,14 @@ impl Document {
             let mut file = File::create(path).await?;
             to_writer(&mut file, encoding, &text).await?;
 
-            if let Some(language_servers) = language_servers {
-                for language_server in language_servers {
-                    if !language_server.is_initialized() {
-                        return Ok(());
-                    }
-                    if let Some(notification) =
-                        language_server.text_document_did_save(identifier.clone(), &text)
-                    {
-                        notification.await?;
-                    }
+            for language_server in language_servers {
+                if !language_server.is_initialized() {
+                    return Ok(());
+                }
+                if let Some(notification) =
+                    language_server.text_document_did_save(identifier.clone(), &text)
+                {
+                    notification.await?;
                 }
             }
 
@@ -631,7 +629,7 @@ impl Document {
     }
 
     /// Set the LSP.
-    pub fn set_language_servers(&mut self, language_servers: Option<Vec<Arc<helix_lsp::Client>>>) {
+    pub fn set_language_servers(&mut self, language_servers: Vec<Arc<helix_lsp::Client>>) {
         self.language_servers = language_servers;
     }
 
@@ -698,18 +696,16 @@ impl Document {
             }
 
             // emit lsp notification
-            if let Some(language_servers) = self.language_servers() {
-                for language_server in language_servers {
-                    let notify = language_server.text_document_did_change(
-                        self.versioned_identifier(),
-                        &old_doc,
-                        self.text(),
-                        transaction.changes(),
-                    );
-
-                    if let Some(notify) = notify {
-                        tokio::spawn(notify);
-                    }
+            for language_server in self.language_servers() {
+                let notify = language_server.text_document_did_change(
+                    self.versioned_identifier(),
+                    &old_doc,
+                    self.text(),
+                    transaction.changes(),
+                );
+
+                if let Some(notify) = notify {
+                    tokio::spawn(notify);
                 }
             }
         }
@@ -863,9 +859,9 @@ impl Document {
     pub fn language_id(&self) -> Option<&str> {
         // TODO is it safe to get the language_id from the first language server that defines it?
         self.language_config()
-            .and_then(|config| config.language_servers.as_ref())
-            .and_then(|lsp_configs| {
-                lsp_configs
+            .and_then(|config| {
+                config
+                    .language_servers
                     .iter()
                     .find_map(|lsp_config| lsp_config.language_id.as_deref())
             })
@@ -883,12 +879,11 @@ impl Document {
     }
 
     /// Language server if it has been initialized.
-    pub fn language_servers(&self) -> Option<Vec<&helix_lsp::Client>> {
-        self.language_servers.as_ref().map(|ls| {
-            ls.iter()
-                .filter_map(|l| if l.is_initialized() { Some(&**l) } else { None })
-                .collect()
-        })
+    pub fn language_servers(&self) -> Vec<&helix_lsp::Client> {
+        self.language_servers
+            .iter()
+            .filter_map(|l| if l.is_initialized() { Some(&**l) } else { None })
+            .collect()
     }
 
     #[inline]
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
diff --git a/xtask/src/main.rs b/xtask/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ fn write_impl(`
`227`	`227`	`if path.is_some() {`
`228`	`228`	`let id = doc.id();`
`229`	`229`	`doc.detect_language(cx.editor.syn_loader.clone());`
`230`		`- let _ = cx.editor.refresh_language_server(id);`
	`230`	`+ let _ = cx.editor.refresh_language_servers(id);`
`231`	`231`	`}`
`232`	`232`	`Ok(())`
`233`	`233`	`}`
`@@ -1007,7 +1007,7 @@ fn language(`
`1007`	`1007`	`doc.set_language_by_language_id(&args[0], cx.editor.syn_loader.clone());`
`1008`	`1008`
`1009`	`1009`	`let id = doc.id();`
`1010`		`- cx.editor.refresh_language_server(id);`
	`1010`	`+ cx.editor.refresh_language_servers(id);`
`1011`	`1011`	`Ok(())`
`1012`	`1012`	`}`
`1013`	`1013`