Send workspace/didChangeWatchedFiles.

Close #347.

Author: autozimu

src/languageclient.rs

@@ -1696,7 +1696,6 @@ impl State {
                         serde_json::from_value(r.register_options.clone().unwrap_or_default())?;
                     if let Some(ref mut watcher) = self.watcher {
                         for w in opt.watchers {
-                            warn!("Start watching {}", w.glob_pattern);
                             watcher.watch(w.glob_pattern, notify::RecursiveMode::NonRecursive)?;
                         }
                     }
@@ -2425,22 +2424,54 @@ impl State {
         Ok(())
     }
 
-    pub fn check_fs_notify(&mut self) -> () {
+    pub fn check_fs_notify(&mut self) -> Result<()> {
         if self.watcher.is_some() {
+            let mut events = vec![];
             loop {
                 let result = self.watcher_rx.try_recv();
                 let event = match result {
                     Ok(event) => event,
                     Err(err) => {
                         if let TryRecvError::Disconnected = err {
-                            warn!("File system notification channel disconnected!");
+                            bail!("File system notification channel disconnected!");
                         }
                         break;
                     }
                 };
+                events.push(event);
+            }
+
+            if events.is_empty() {
+                return Ok(());
+            }
 
-                warn!("File system event: {:?}", event);
+            let mut changes = vec![];
+            for e in events {
+                if let Ok(c) = e.to_lsp() {
+                    changes.extend(c);
+                }
             }
+
+            use DidChangeWatchedFilesParams as P;
+            self.workspace_didChangeWatchedFiles(&P { changes }.to_params()?)?;
         }
+
+        Ok(())
+    }
+
+    pub fn workspace_didChangeWatchedFiles(&mut self, params: &Option<Params>) -> Result<()> {
+        info!("Begin {}", lsp::notification::DidChangeWatchedFiles::METHOD);
+        let (languageId,): (String,) = self.gather_args([VimVar::LanguageId].as_ref(), params)?;
+
+        let params: DidChangeWatchedFilesParams =
+            serde_json::from_value(params.clone().to_value())?;
+        self.notify(
+            Some(&languageId),
+            lsp::notification::DidChangeWatchedFiles::METHOD,
+            params,
+        )?;
+
+        info!("End {}", lsp::notification::DidChangeWatchedFiles::METHOD);
+        Ok(())
     }
 }

src/types.rs

@@ -861,3 +861,48 @@ impl<T: Deref> OptionDeref<T> for Option<T> {
         self.as_ref().map(Deref::deref)
     }
 }
+
+pub trait ToLSP<T> {
+    fn to_lsp(&self) -> Result<T>;
+}
+
+impl ToLSP<Vec<FileEvent>> for notify::DebouncedEvent {
+    fn to_lsp(&self) -> Result<Vec<FileEvent>> {
+        match *self {
+            notify::DebouncedEvent::Create(ref p) => Ok(vec![
+                FileEvent {
+                    uri: p.to_url()?,
+                    typ: FileChangeType::Created,
+                },
+            ]),
+            notify::DebouncedEvent::NoticeWrite(ref p) | notify::DebouncedEvent::Write(ref p) => {
+                Ok(vec![
+                    FileEvent {
+                        uri: p.to_url()?,
+                        typ: FileChangeType::Changed,
+                    },
+                ])
+            }
+            notify::DebouncedEvent::NoticeRemove(ref p) | notify::DebouncedEvent::Remove(ref p) => {
+                Ok(vec![
+                    FileEvent {
+                        uri: p.to_url()?,
+                        typ: FileChangeType::Deleted,
+                    },
+                ])
+            }
+            notify::DebouncedEvent::Rename(ref p1, ref p2) => Ok(vec![
+                FileEvent {
+                    uri: p1.to_url()?,
+                    typ: FileChangeType::Deleted,
+                },
+                FileEvent {
+                    uri: p2.to_url()?,
+                    typ: FileChangeType::Created,
+                },
+            ]),
+            notify::DebouncedEvent::Chmod(_) | notify::DebouncedEvent::Rescan => Ok(vec![]),
+            ref e @ notify::DebouncedEvent::Error(_, _) => Err(format_err!("{:?}", e)),
+        }
+    }
+}

src/vim.rs

@@ -79,7 +79,9 @@ impl State {
                 }
             }
 
-            self.check_fs_notify();
+            if let Err(err) = self.check_fs_notify() {
+                warn!("{:?}", err);
+            }
         }
     }