Update signs only at visible lines.

Author: autozimu

autoload/LSP.vim

@@ -30,3 +30,11 @@ function! LSP#range_end_line() abort
 
     return getpos("'>")[1]
 endfunction
+
+function! LSP#visible_line_start() abort
+    return line('w0')
+endfunction
+
+function! LSP#visible_line_end() abort
+    return line('w$')
+endfunction

autoload/LanguageClient.vim

@@ -742,6 +742,8 @@ function! LanguageClient#handleCursorMoved() abort
                     \ 'buftype': &buftype,
                     \ 'filename': LSP#filename(),
                     \ 'line': l:cursor_line,
+                    \ 'LSP#visible_line_start()': LSP#visible_line_start(),
+                    \ 'LSP#visible_line_end()': LSP#visible_line_end(),
                     \ })
     catch
         call s:Debug('LanguageClient caught exception: ' . string(v:exception))

src/languageclient.rs

@@ -330,7 +330,7 @@ impl State {
         Ok(())
     }
 
-    fn display_diagnostics(&mut self, filename: &str, diagnostics: &[Diagnostic]) -> Result<()> {
+    fn process_diagnostics(&mut self, filename: &str, diagnostics: &[Diagnostic]) -> Result<()> {
         // Line diagnostics.
         self.update(|state| {
             state
@@ -360,38 +360,36 @@ impl State {
         })?;
 
         // Signs.
-        if self.text_documents.contains_key(filename) {
-            let text = self.text_documents
+        {
+            let lines: Option<Vec<_>> = self.text_documents
                 .get(filename)
-                .ok_or_else(|| format_err!("TextDocumentItem not found! filename: {}", filename))?
-                .text
-                .clone();
-            let lines: Vec<&str> = text.lines().collect();
-            let mut signs: Vec<_> = diagnostics
-                .iter()
-                .map(|dn| {
-                    let line = dn.range.start.line;
-                    let text = lines
-                        .get(line as usize)
-                        .map(|l| l.to_string())
-                        .unwrap_or_default();
-                    Some(Sign::new(line + 1, text, dn.severity))
-                })
-                .collect();
+                .map(|d| d.text.lines().collect());
+            let mut signs = if let Some(lines) = lines {
+                diagnostics
+                    .iter()
+                    .map(|dn| {
+                        let line = dn.range.start.line;
+                        let text = lines
+                            .get(line as usize)
+                            .map(|l| l.to_string())
+                            .unwrap_or_default();
+
+                        Sign::new(line + 1, text, dn.severity)
+                    })
+                    .collect()
+            } else {
+                vec![]
+            };
+
+            // There might be multiple diagnostics for one line. Show only highest severity.
             signs.sort_unstable();
-            signs.dedup_by_key(|s| s.line);
+            signs.dedup();
+
             if let Some(diagnosticSignsMax) = self.diagnosticsSignsMax {
                 signs.truncate(diagnosticSignsMax as usize);
             }
 
-            let cmd = self.update(|state| {
-                let signs_prev = state.signs.remove(filename).unwrap_or_default();
-                let (signs_next, cmd) = get_command_update_signs(&signs_prev, &signs, filename);
-                state.signs.insert(filename.to_string(), signs_next);
-                Ok(cmd)
-            })?;
-            info!("Command to update signs: {}", cmd);
-            self.command(&cmd)?;
+            self.signs.insert(filename.to_owned(), signs);
         }
 
         let diagnosticsDisplay = self.get(|state| Ok(state.diagnosticsDisplay.clone()))?;
@@ -708,8 +706,9 @@ impl State {
             }
         }
         for f in filenames {
-            self.display_diagnostics(&f, &[])?;
+            self.process_diagnostics(&f, &[])?;
         }
+        self.languageClient_handleCursorMoved(&json!({}).to_params()?)?;
 
         self.diagnostics.retain(|f, _| !f.starts_with(&root));
         self.update_quickfixlist()?;
@@ -1818,7 +1817,8 @@ impl State {
         if filename != current_filename.canonicalize() {
             return Ok(());
         }
-        self.display_diagnostics(&current_filename, &diagnostics)?;
+        self.process_diagnostics(&current_filename, &diagnostics)?;
+        self.languageClient_handleCursorMoved(&json!({}).to_params()?)?;
         self.call::<_, u8>(None, "s:ExecuteAutocmd", "LanguageClientDiagnosticsChanged")?;
 
         info!("End {}", lsp::notification::PublishDiagnostics::METHOD);
@@ -2071,7 +2071,7 @@ impl State {
             self.textDocument_didOpen(params)?;
 
             if let Some(diagnostics) = self.diagnostics.get(&filename).cloned() {
-                self.display_diagnostics(&filename, &diagnostics)?;
+                self.process_diagnostics(&filename, &diagnostics)?;
                 self.languageClient_handleCursorMoved(params)?;
             }
         } else {
@@ -2145,36 +2145,51 @@ impl State {
         info!("Begin {}", NOTIFICATION__HandleCursorMoved);
         let (buftype, filename, line): (String, String, u64) =
             self.gather_args(&[VimVar::Buftype, VimVar::Filename, VimVar::Line], params)?;
-        if !buftype.is_empty() || line == self.get(|state| Ok(state.last_cursor_line))? {
+        let (visible_line_start, visible_line_end): (u64, u64) = self.gather_args(
+            &["LSP#visible_line_start()", "LSP#visible_line_end()"],
+            params,
+        )?;
+        if !buftype.is_empty() && !self.diagnostics.contains_key(&filename) {
             return Ok(());
         }
 
-        self.update(|state| {
-            state.last_cursor_line = line;
-            Ok(())
-        })?;
-        let message = self.get(|state| {
-            state
-                .line_diagnostics
+        if line != self.last_cursor_line {
+            self.last_cursor_line = line;
+
+            let message = self.line_diagnostics
                 .get(&(filename.clone(), line))
                 .cloned()
-                .ok_or_else(|| {
-                    format_err!(
-                        "Line diagnostic message not found! filename: {}, line: {}",
-                        filename,
-                        line
-                    )
-                })
-        }).unwrap_or_default();
-        if message == self.get(|state| Ok(state.last_line_diagnostic.clone()))? {
-            return Ok(());
+                .unwrap_or_default();
+
+            if message != self.last_line_diagnostic {
+                self.echo_ellipsis(&message)?;
+                self.last_line_diagnostic = message;
+            }
         }
 
-        self.update(|state| {
-            state.last_line_diagnostic = message.clone();
-            Ok(())
-        })?;
-        self.echo_ellipsis(&message)?;
+        let signs_prev = self.signs_placed
+            .get(&filename)
+            .cloned()
+            .unwrap_or_default();
+        let signs: Vec<_> = self.signs
+            .entry(filename.clone())
+            .or_insert_with(|| vec![])
+            .iter()
+            .filter_map(|s| {
+                if s.line < visible_line_start || s.line > visible_line_end {
+                    return None;
+                }
+
+                Some(s.clone())
+            })
+            .collect();
+        if signs != signs_prev {
+            let (signs, cmds) = get_command_update_signs(&signs_prev, &signs, &filename);
+            self.signs_placed.insert(filename.clone(), signs);
+
+            info!("Updating signs: {:?}", cmds);
+            self.command(&cmds)?;
+        }
 
         info!("End {}", NOTIFICATION__HandleCursorMoved);
         Ok(())

src/types.rs

@@ -101,6 +101,7 @@ pub struct State {
     #[serde(skip_serializing)]
     pub line_diagnostics: HashMap<(String, u64), String>,
     pub signs: HashMap<String, Vec<Sign>>,
+    pub signs_placed: HashMap<String, Vec<Sign>>,
     pub highlight_source: Option<u64>,
     // TODO: make file specific.
     pub highlight_match_ids: Vec<u32>,
@@ -163,6 +164,7 @@ impl State {
             diagnostics: HashMap::new(),
             line_diagnostics: HashMap::new(),
             signs: HashMap::new(),
+            signs_placed: HashMap::new(),
             highlight_source: None,
             highlight_match_ids: Vec::new(),
             user_handlers: HashMap::new(),

src/utils.rs

@@ -219,34 +219,37 @@ fn test_apply_TextEdit_overlong_end() {
 
 fn get_command_add_sign(sign: &Sign, filename: &str) -> String {
     format!(
-        " | execute 'sign place {} line={} name=LanguageClient{:?} file={}'",
-        sign.id, sign.line, sign.severity, filename
+        "sign place {} line={} name=LanguageClient{:?} file={}",
+        sign.id,
+        sign.line,
+        sign.severity.unwrap_or(DiagnosticSeverity::Hint),
+        filename
     )
 }
 
 #[test]
 fn test_get_command_add_sign() {
-    let sign = Sign::new(1, "".to_owned(), DiagnosticSeverity::Error);
+    let sign = Sign::new(1, "".to_owned(), Some(DiagnosticSeverity::Error));
     assert_eq!(
         get_command_add_sign(&sign, ""),
-        " | execute 'sign place 75000 line=1 name=LanguageClientError file='"
+        "sign place 75000 line=1 name=LanguageClientError file="
     );
 
-    let sign = Sign::new(7, "".to_owned(), DiagnosticSeverity::Error);
+    let sign = Sign::new(7, "".to_owned(), Some(DiagnosticSeverity::Error));
     assert_eq!(
         get_command_add_sign(&sign, ""),
-        " | execute 'sign place 75024 line=7 name=LanguageClientError file='"
+        "sign place 75024 line=7 name=LanguageClientError file="
     );
 
-    let sign = Sign::new(7, "".to_owned(), DiagnosticSeverity::Hint);
+    let sign = Sign::new(7, "".to_owned(), Some(DiagnosticSeverity::Hint));
     assert_eq!(
         get_command_add_sign(&sign, ""),
-        " | execute 'sign place 75027 line=7 name=LanguageClientHint file='"
+        "sign place 75027 line=7 name=LanguageClientHint file="
     );
 }
 
 fn get_command_delete_sign(sign: &Sign, filename: &str) -> String {
-    format!(" | execute 'sign unplace {} file={}'", sign.id, filename)
+    format!("sign unplace {} file={}", sign.id, filename)
 }
 
 #[test]
@@ -258,19 +261,19 @@ pub fn get_command_update_signs(
     signs_prev: &[Sign],
     signs: &[Sign],
     filename: &str,
-) -> (Vec<Sign>, String) {
+) -> (Vec<Sign>, Vec<String>) {
     // Sign id might become different due to lines shifting. Use sign's existing sign id to
     // track same sign.
     let mut signs_next = vec![];
 
-    let mut cmd = "echo".to_owned();
+    let mut cmds = vec![];
     for comp in diff::slice(signs_prev, signs) {
         match comp {
             diff::Result::Left(sign) => {
-                cmd += &get_command_delete_sign(sign, filename);
+                cmds.push(get_command_delete_sign(sign, filename));
             }
             diff::Result::Right(sign) => {
-                cmd += &get_command_add_sign(sign, filename);
+                cmds.push(get_command_add_sign(sign, filename));
                 signs_next.push(sign.clone());
             }
             diff::Result::Both(sign, _) => {
@@ -279,19 +282,27 @@ pub fn get_command_update_signs(
         }
     }
 
-    (signs_next, cmd)
+    (signs_next, cmds)
 }
 
 #[test]
 fn test_get_command_update_signs() {
-    let signs_prev = vec![Sign::new(1, "abcde".to_string(), DiagnosticSeverity::Error)];
-    let signs = vec![Sign::new(3, "abcde".to_string(), DiagnosticSeverity::Error)];
-    let (signs_next, cmd) = get_command_update_signs(&signs_prev, &signs, "f");
+    let signs_prev = vec![Sign::new(
+        1,
+        "abcde".to_string(),
+        Some(DiagnosticSeverity::Error),
+    )];
+    let signs = vec![Sign::new(
+        3,
+        "abcde".to_string(),
+        Some(DiagnosticSeverity::Error),
+    )];
+    let (signs_next, cmds) = get_command_update_signs(&signs_prev, &signs, "f");
     assert_eq!(
         serde_json::to_string(&signs_next).unwrap(),
         "[{\"id\":75000,\"line\":1,\"text\":\"abcde\",\"severity\":1}]"
     );
-    assert_eq!(cmd, "echo");
+    assert!(cmds.is_empty());
 }
 
 pub trait Combine {

src/vim.rs

@@ -187,10 +187,9 @@ impl State {
         Ok(serde_json::from_value(result)?)
     }
 
-    pub fn command<S: AsRef<str>>(&mut self, cmd: S) -> Result<()> {
-        let cmd = cmd.as_ref();
-        if self.call::<_, u8>(None, "execute", cmd)? != 0 {
-            bail!("Failed to execute command: {}", cmd);
+    pub fn command<P: Serialize + Debug>(&mut self, cmds: P) -> Result<()> {
+        if self.call::<_, u8>(None, "execute", &cmds)? != 0 {
+            bail!("Failed to execute command: {:?}", cmds);
         }
         Ok(())
     }