5 files changed, 660 insertions, 202 deletions

diff --git a/crates/ra_vfs/Cargo.toml b/crates/ra_vfs/Cargo.toml
index e637063c9..383381d2a 100644
--- a/crates/ra_vfs/Cargo.toml
+++ b/crates/ra_vfs/Cargo.toml
@@ -10,9 +10,13 @@ relative-path = "0.4.0"
 rustc-hash = "1.0"
 crossbeam-channel = "0.3.5"
 log = "0.4.6"
+notify = "4.0.7"
+drop_bomb = "0.1.0"
+parking_lot = "0.7.0"
 
 thread_worker = { path = "../thread_worker" }
 ra_arena = { path = "../ra_arena" }
 
 [dev-dependencies]
 tempfile = "3"
+flexi_logger = "0.10.0"
diff --git a/crates/ra_vfs/src/io.rs b/crates/ra_vfs/src/io.rs
index 80328ad18..7ca1e9835 100644
--- a/crates/ra_vfs/src/io.rs
+++ b/crates/ra_vfs/src/io.rs
@@ -1,55 +1,109 @@
-use std::{
-    fmt,
-    fs,
-    path::{Path, PathBuf},
-};
+use std::{fs, sync::Arc, thread};
 
-use walkdir::{DirEntry, WalkDir};
-use thread_worker::{WorkerHandle};
+use crossbeam_channel::{Receiver, Sender};
 use relative_path::RelativePathBuf;
+use thread_worker::WorkerHandle;
+use walkdir::WalkDir;
 
-use crate::{VfsRoot, has_rs_extension};
+mod watcher;
+use watcher::Watcher;
 
-pub(crate) struct Task {
-    pub(crate) root: VfsRoot,
-    pub(crate) path: PathBuf,
-    pub(crate) filter: Box<Fn(&DirEntry) -> bool + Send>,
+use crate::{RootFilter, Roots, VfsRoot};
+
+pub(crate) enum Task {
+    AddRoot {
+        root: VfsRoot,
+        filter: Arc<RootFilter>,
+    },
 }
 
-pub struct TaskResult {
-    pub(crate) root: VfsRoot,
-    pub(crate) files: Vec<(RelativePathBuf, String)>,
+#[derive(Debug)]
+pub enum TaskResult {
+    BulkLoadRoot {
+        root: VfsRoot,
+        files: Vec<(RelativePathBuf, String)>,
+    },
+    AddSingleFile {
+        root: VfsRoot,
+        path: RelativePathBuf,
+        text: String,
+    },
+    ChangeSingleFile {
+        root: VfsRoot,
+        path: RelativePathBuf,
+        text: String,
+    },
+    RemoveSingleFile {
+        root: VfsRoot,
+        path: RelativePathBuf,
+    },
 }
 
-impl fmt::Debug for TaskResult {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("TaskResult { ... }")
-    }
+pub(crate) struct Worker {
+    worker: thread_worker::Worker<Task, TaskResult>,
+    worker_handle: WorkerHandle,
 }
 
-pub(crate) type Worker = thread_worker::Worker<Task, TaskResult>;
+impl Worker {
+    pub(crate) fn start(roots: Arc<Roots>) -> Worker {
+        let (worker, worker_handle) =
+            thread_worker::spawn("vfs", 128, move |input_receiver, output_sender| {
+                let mut watcher = match Watcher::start(roots, output_sender.clone()) {
+                    Ok(w) => Some(w),
+                    Err(e) => {
+                        log::error!("could not start watcher: {}", e);
+                        None
+                    }
+                };
+                let res = input_receiver
+                    .into_iter()
+                    .filter_map(|t| handle_task(t, &mut watcher))
+                    .try_for_each(|it| output_sender.send(it));
+                if let Some(watcher) = watcher {
+                    let _ = watcher.shutdown();
+                }
+                res.unwrap()
+            });
+        Worker {
+            worker,
+            worker_handle,
+        }
+    }
+
+    pub(crate) fn sender(&self) -> &Sender<Task> {
+        &self.worker.inp
+    }
+
+    pub(crate) fn receiver(&self) -> &Receiver<TaskResult> {
+        &self.worker.out
+    }
 
-pub(crate) fn start() -> (Worker, WorkerHandle) {
-    thread_worker::spawn("vfs", 128, |input_receiver, output_sender| {
-        input_receiver
-            .into_iter()
-            .map(handle_task)
-            .try_for_each(|it| output_sender.send(it))
-            .unwrap()
-    })
+    pub(crate) fn shutdown(self) -> thread::Result<()> {
+        let _ = self.worker.shutdown();
+        self.worker_handle.shutdown()
+    }
 }
 
-fn handle_task(task: Task) -> TaskResult {
-    let Task { root, path, filter } = task;
-    log::debug!("loading {} ...", path.as_path().display());
-    let files = load_root(path.as_path(), &*filter);
-    log::debug!("... loaded {}", path.as_path().display());
-    TaskResult { root, files }
+fn handle_task(task: Task, watcher: &mut Option<Watcher>) -> Option<TaskResult> {
+    match task {
+        Task::AddRoot { root, filter } => {
+            if let Some(watcher) = watcher {
+                watcher.watch_root(&filter)
+            }
+            log::debug!("loading {} ...", filter.root.as_path().display());
+            let files = load_root(filter.as_ref());
+            log::debug!("... loaded {}", filter.root.as_path().display());
+            Some(TaskResult::BulkLoadRoot { root, files })
+        }
+    }
 }
 
-fn load_root(root: &Path, filter: &dyn Fn(&DirEntry) -> bool) -> Vec<(RelativePathBuf, String)> {
+fn load_root(filter: &RootFilter) -> Vec<(RelativePathBuf, String)> {
     let mut res = Vec::new();
-    for entry in WalkDir::new(root).into_iter().filter_entry(filter) {
+    for entry in WalkDir::new(&filter.root)
+        .into_iter()
+        .filter_entry(filter.entry_filter())
+    {
         let entry = match entry {
             Ok(entry) => entry,
             Err(e) => {
@@ -61,9 +115,6 @@ fn load_root(root: &Path, filter: &dyn Fn(&DirEntry) -> bool) -> Vec<(RelativePa
             continue;
         }
         let path = entry.path();
-        if !has_rs_extension(path) {
-            continue;
-        }
         let text = match fs::read_to_string(path) {
             Ok(text) => text,
             Err(e) => {
@@ -71,7 +122,7 @@ fn load_root(root: &Path, filter: &dyn Fn(&DirEntry) -> bool) -> Vec<(RelativePa
                 continue;
             }
         };
-        let path = RelativePathBuf::from_path(path.strip_prefix(root).unwrap()).unwrap();
+        let path = RelativePathBuf::from_path(path.strip_prefix(&filter.root).unwrap()).unwrap();
         res.push((path.to_owned(), text))
     }
     res
diff --git a/crates/ra_vfs/src/io/watcher.rs b/crates/ra_vfs/src/io/watcher.rs
new file mode 100644
index 000000000..ff6775f59
--- /dev/null
+++ b/crates/ra_vfs/src/io/watcher.rs
@@ -0,0 +1,200 @@
+use crate::{io, RootFilter, Roots, VfsRoot};
+use crossbeam_channel::Sender;
+use drop_bomb::DropBomb;
+use notify::{DebouncedEvent, RecommendedWatcher, RecursiveMode, Watcher as NotifyWatcher};
+use parking_lot::Mutex;
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    sync::{mpsc, Arc},
+    thread,
+    time::Duration,
+};
+use walkdir::WalkDir;
+
+#[derive(Debug)]
+enum ChangeKind {
+    Create,
+    Write,
+    Remove,
+}
+
+const WATCHER_DELAY: Duration = Duration::from_millis(250);
+
+pub(crate) struct Watcher {
+    thread: thread::JoinHandle<()>,
+    bomb: DropBomb,
+    watcher: Arc<Mutex<Option<RecommendedWatcher>>>,
+}
+
+impl Watcher {
+    pub(crate) fn start(
+        roots: Arc<Roots>,
+        output_sender: Sender<io::TaskResult>,
+    ) -> Result<Watcher, Box<std::error::Error>> {
+        let (input_sender, input_receiver) = mpsc::channel();
+        let watcher = Arc::new(Mutex::new(Some(notify::watcher(
+            input_sender,
+            WATCHER_DELAY,
+        )?)));
+        let sender = output_sender.clone();
+        let watcher_clone = watcher.clone();
+        let thread = thread::spawn(move || {
+            let worker = WatcherWorker {
+                roots,
+                watcher: watcher_clone,
+                sender,
+            };
+            input_receiver
+                .into_iter()
+                // forward relevant events only
+                .try_for_each(|change| worker.handle_debounced_event(change))
+                .unwrap()
+        });
+        Ok(Watcher {
+            thread,
+            watcher,
+            bomb: DropBomb::new(format!("Watcher was not shutdown")),
+        })
+    }
+
+    pub fn watch_root(&mut self, filter: &RootFilter) {
+        for res in WalkDir::new(&filter.root)
+            .into_iter()
+            .filter_entry(filter.entry_filter())
+        {
+            match res {
+                Ok(entry) => {
+                    if entry.file_type().is_dir() {
+                        watch_one(self.watcher.as_ref(), entry.path());
+                    }
+                }
+                Err(e) => log::warn!("watcher error: {}", e),
+            }
+        }
+    }
+
+    pub fn shutdown(mut self) -> thread::Result<()> {
+        self.bomb.defuse();
+        drop(self.watcher.lock().take());
+        let res = self.thread.join();
+        match &res {
+            Ok(()) => log::info!("... Watcher terminated with ok"),
+            Err(_) => log::error!("... Watcher terminated with err"),
+        }
+        res
+    }
+}
+
+struct WatcherWorker {
+    watcher: Arc<Mutex<Option<RecommendedWatcher>>>,
+    roots: Arc<Roots>,
+    sender: Sender<io::TaskResult>,
+}
+
+impl WatcherWorker {
+    fn handle_debounced_event(&self, ev: DebouncedEvent) -> Result<(), Box<std::error::Error>> {
+        match ev {
+            DebouncedEvent::NoticeWrite(_)
+            | DebouncedEvent::NoticeRemove(_)
+            | DebouncedEvent::Chmod(_) => {
+                // ignore
+            }
+            DebouncedEvent::Rescan => {
+                // TODO rescan all roots
+            }
+            DebouncedEvent::Create(path) => {
+                self.handle_change(path, ChangeKind::Create);
+            }
+            DebouncedEvent::Write(path) => {
+                self.handle_change(path, ChangeKind::Write);
+            }
+            DebouncedEvent::Remove(path) => {
+                self.handle_change(path, ChangeKind::Remove);
+            }
+            DebouncedEvent::Rename(src, dst) => {
+                self.handle_change(src, ChangeKind::Remove);
+                self.handle_change(dst, ChangeKind::Create);
+            }
+            DebouncedEvent::Error(err, path) => {
+                // TODO should we reload the file contents?
+                log::warn!("watcher error \"{}\", {:?}", err, path);
+            }
+        }
+        Ok(())
+    }
+
+    fn handle_change(&self, path: PathBuf, kind: ChangeKind) {
+        if let Err(e) = self.try_handle_change(path, kind) {
+            log::warn!("watcher error: {}", e)
+        }
+    }
+
+    fn try_handle_change(
+        &self,
+        path: PathBuf,
+        kind: ChangeKind,
+    ) -> Result<(), Box<std::error::Error>> {
+        let (root, rel_path) = match self.roots.find(&path) {
+            Some(x) => x,
+            None => return Ok(()),
+        };
+        match kind {
+            ChangeKind::Create => {
+                if path.is_dir() {
+                    self.watch_recursive(&path, root);
+                } else {
+                    let text = fs::read_to_string(&path)?;
+                    self.sender.send(io::TaskResult::AddSingleFile {
+                        root,
+                        path: rel_path,
+                        text,
+                    })?
+                }
+            }
+            ChangeKind::Write => {
+                let text = fs::read_to_string(&path)?;
+                self.sender.send(io::TaskResult::ChangeSingleFile {
+                    root,
+                    path: rel_path,
+                    text,
+                })?
+            }
+            ChangeKind::Remove => self.sender.send(io::TaskResult::RemoveSingleFile {
+                root,
+                path: rel_path,
+            })?,
+        }
+        Ok(())
+    }
+
+    fn watch_recursive(&self, dir: &Path, root: VfsRoot) {
+        let filter = &self.roots[root];
+        for res in WalkDir::new(dir)
+            .into_iter()
+            .filter_entry(filter.entry_filter())
+        {
+            match res {
+                Ok(entry) => {
+                    if entry.file_type().is_dir() {
+                        watch_one(self.watcher.as_ref(), entry.path());
+                    } else {
+                        // emit only for files otherwise we will cause watch_recursive to be called again with a dir that we are already watching
+                        // emit as create because we haven't seen it yet
+                        self.handle_change(entry.path().to_path_buf(), ChangeKind::Create);
+                    }
+                }
+                Err(e) => log::warn!("watcher error: {}", e),
+            }
+        }
+    }
+}
+
+fn watch_one(watcher: &Mutex<Option<RecommendedWatcher>>, dir: &Path) {
+    if let Some(watcher) = watcher.lock().as_mut() {
+        match watcher.watch(dir, RecursiveMode::NonRecursive) {
+            Ok(()) => log::debug!("watching \"{}\"", dir.display()),
+            Err(e) => log::warn!("could not watch \"{}\": {}", dir.display(), e),
+        }
+    }
+}
diff --git a/crates/ra_vfs/src/lib.rs b/crates/ra_vfs/src/lib.rs
index cdea18d73..70a13f765 100644
--- a/crates/ra_vfs/src/lib.rs
+++ b/crates/ra_vfs/src/lib.rs
@@ -16,52 +16,77 @@
 mod io;
 
 use std::{
-    fmt,
-    mem,
-    thread,
     cmp::Reverse,
+    fmt, fs, mem,
+    ops::{Deref, DerefMut},
     path::{Path, PathBuf},
-    ffi::OsStr,
     sync::Arc,
-    fs,
+    thread,
 };
 
-use rustc_hash::{FxHashMap, FxHashSet};
-use relative_path::RelativePathBuf;
 use crossbeam_channel::Receiver;
+use ra_arena::{impl_arena_id, Arena, RawId};
+use relative_path::{Component, RelativePath, RelativePathBuf};
+use rustc_hash::{FxHashMap, FxHashSet};
 use walkdir::DirEntry;
-use thread_worker::WorkerHandle;
-use ra_arena::{Arena, RawId, impl_arena_id};
 
 pub use crate::io::TaskResult as VfsTask;
+use io::{TaskResult, Worker};
 
 /// `RootFilter` is a predicate that checks if a file can belong to a root. If
 /// several filters match a file (nested dirs), the most nested one wins.
-struct RootFilter {
+pub(crate) struct RootFilter {
     root: PathBuf,
-    file_filter: fn(&Path) -> bool,
+    filter: fn(&Path, &RelativePath) -> bool,
+    excluded_dirs: Vec<PathBuf>,
 }
 
 impl RootFilter {
-    fn new(root: PathBuf) -> RootFilter {
+    fn new(root: PathBuf, excluded_dirs: Vec<PathBuf>) -> RootFilter {
         RootFilter {
             root,
-            file_filter: has_rs_extension,
+            filter: default_filter,
+            excluded_dirs,
         }
     }
     /// Check if this root can contain `path`. NB: even if this returns
     /// true, the `path` might actually be conained in some nested root.
-    fn can_contain(&self, path: &Path) -> Option<RelativePathBuf> {
-        if !(self.file_filter)(path) {
+    pub(crate) fn can_contain(&self, path: &Path) -> Option<RelativePathBuf> {
+        let rel_path = path.strip_prefix(&self.root).ok()?;
+        let rel_path = RelativePathBuf::from_path(rel_path).ok()?;
+        if !(self.filter)(path, rel_path.as_relative_path()) {
             return None;
         }
-        let path = path.strip_prefix(&self.root).ok()?;
-        RelativePathBuf::from_path(path).ok()
+        Some(rel_path)
+    }
+
+    pub(crate) fn entry_filter<'a>(&'a self) -> impl FnMut(&DirEntry) -> bool + 'a {
+        move |entry: &DirEntry| {
+            if entry.file_type().is_dir() && self.excluded_dirs.iter().any(|it| it == entry.path())
+            {
+                // do not walk nested roots
+                false
+            } else {
+                self.can_contain(entry.path()).is_some()
+            }
+        }
     }
 }
 
-fn has_rs_extension(p: &Path) -> bool {
-    p.extension() == Some(OsStr::new("rs"))
+pub(crate) fn default_filter(path: &Path, rel_path: &RelativePath) -> bool {
+    if path.is_dir() {
+        for (i, c) in rel_path.components().enumerate() {
+            if let Component::Normal(c) = c {
+                // TODO hardcoded for now
+                if (i == 0 && c == "target") || c == ".git" || c == "node_modules" {
+                    return false;
+                }
+            }
+        }
+        true
+    } else {
+        rel_path.extension() == Some("rs")
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -75,16 +100,58 @@ impl_arena_id!(VfsFile);
 struct VfsFileData {
     root: VfsRoot,
     path: RelativePathBuf,
+    is_overlayed: bool,
     text: Arc<String>,
 }
 
+pub(crate) struct Roots {
+    roots: Arena<VfsRoot, Arc<RootFilter>>,
+}
+
+impl Roots {
+    pub(crate) fn new(mut paths: Vec<PathBuf>) -> Roots {
+        let mut roots = Arena::default();
+        // A hack to make nesting work.
+        paths.sort_by_key(|it| Reverse(it.as_os_str().len()));
+        for (i, path) in paths.iter().enumerate() {
+            let nested_roots = paths[..i]
+                .iter()
+                .filter(|it| it.starts_with(path))
+                .map(|it| it.clone())
+                .collect::<Vec<_>>();
+
+            let root_filter = Arc::new(RootFilter::new(path.clone(), nested_roots));
+
+            roots.alloc(root_filter.clone());
+        }
+        Roots { roots }
+    }
+    pub(crate) fn find(&self, path: &Path) -> Option<(VfsRoot, RelativePathBuf)> {
+        self.roots
+            .iter()
+            .find_map(|(root, data)| data.can_contain(path).map(|it| (root, it)))
+    }
+}
+
+impl Deref for Roots {
+    type Target = Arena<VfsRoot, Arc<RootFilter>>;
+    fn deref(&self) -> &Self::Target {
+        &self.roots
+    }
+}
+
+impl DerefMut for Roots {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.roots
+    }
+}
+
 pub struct Vfs {
-    roots: Arena<VfsRoot, RootFilter>,
+    roots: Arc<Roots>,
     files: Arena<VfsFile, VfsFileData>,
     root2files: FxHashMap<VfsRoot, FxHashSet<VfsFile>>,
     pending_changes: Vec<VfsChange>,
-    worker: io::Worker,
-    worker_handle: WorkerHandle,
+    worker: Worker,
 }
 
 impl fmt::Debug for Vfs {
@@ -94,44 +161,30 @@ impl fmt::Debug for Vfs {
 }
 
 impl Vfs {
-    pub fn new(mut roots: Vec<PathBuf>) -> (Vfs, Vec<VfsRoot>) {
-        let (worker, worker_handle) = io::start();
-
-        let mut res = Vfs {
-            roots: Arena::default(),
+    pub fn new(roots: Vec<PathBuf>) -> (Vfs, Vec<VfsRoot>) {
+        let roots = Arc::new(Roots::new(roots));
+        let worker = io::Worker::start(roots.clone());
+        let mut root2files = FxHashMap::default();
+
+        for (root, filter) in roots.iter() {
+            root2files.insert(root, Default::default());
+            worker
+                .sender()
+                .send(io::Task::AddRoot {
+                    root,
+                    filter: filter.clone(),
+                })
+                .unwrap();
+        }
+        let res = Vfs {
+            roots,
             files: Arena::default(),
-            root2files: FxHashMap::default(),
+            root2files,
             worker,
-            worker_handle,
             pending_changes: Vec::new(),
         };
-
-        // A hack to make nesting work.
-        roots.sort_by_key(|it| Reverse(it.as_os_str().len()));
-        for (i, path) in roots.iter().enumerate() {
-            let root = res.roots.alloc(RootFilter::new(path.clone()));
-            res.root2files.insert(root, Default::default());
-            let nested = roots[..i]
-                .iter()
-                .filter(|it| it.starts_with(path))
-                .map(|it| it.clone())
-                .collect::<Vec<_>>();
-            let filter = move |entry: &DirEntry| {
-                if entry.file_type().is_file() {
-                    has_rs_extension(entry.path())
-                } else {
-                    nested.iter().all(|it| it != entry.path())
-                }
-            };
-            let task = io::Task {
-                root,
-                path: path.clone(),
-                filter: Box::new(filter),
-            };
-            res.worker.inp.send(task).unwrap();
-        }
-        let roots = res.roots.iter().map(|(id, _)| id).collect();
-        (res, roots)
+        let vfs_roots = res.roots.iter().map(|(id, _)| id).collect();
+        (res, vfs_roots)
     }
 
     pub fn root2path(&self, root: VfsRoot) -> PathBuf {
@@ -165,7 +218,7 @@ impl Vfs {
             } else {
                 let text = fs::read_to_string(path).unwrap_or_default();
                 let text = Arc::new(text);
-                let file = self.add_file(root, rel_path.clone(), Arc::clone(&text));
+                let file = self.add_file(root, rel_path.clone(), Arc::clone(&text), false);
                 let change = VfsChange::AddFile {
                     file,
                     text,
@@ -180,85 +233,132 @@ impl Vfs {
     }
 
     pub fn task_receiver(&self) -> &Receiver<io::TaskResult> {
-        &self.worker.out
+        self.worker.receiver()
     }
 
     pub fn handle_task(&mut self, task: io::TaskResult) {
-        let mut files = Vec::new();
-        // While we were scanning the root in the backgound, a file might have
-        // been open in the editor, so we need to account for that.
-        let exising = self.root2files[&task.root]
-            .iter()
-            .map(|&file| (self.files[file].path.clone(), file))
-            .collect::<FxHashMap<_, _>>();
-        for (path, text) in task.files {
-            if let Some(&file) = exising.get(&path) {
-                let text = Arc::clone(&self.files[file].text);
-                files.push((file, path, text));
-                continue;
+        match task {
+            TaskResult::BulkLoadRoot { root, files } => {
+                let mut cur_files = Vec::new();
+                // While we were scanning the root in the backgound, a file might have
+                // been open in the editor, so we need to account for that.
+                let exising = self.root2files[&root]
+                    .iter()
+                    .map(|&file| (self.files[file].path.clone(), file))
+                    .collect::<FxHashMap<_, _>>();
+                for (path, text) in files {
+                    if let Some(&file) = exising.get(&path) {
+                        let text = Arc::clone(&self.files[file].text);
+                        cur_files.push((file, path, text));
+                        continue;
+                    }
+                    let text = Arc::new(text);
+                    let file = self.add_file(root, path.clone(), Arc::clone(&text), false);
+                    cur_files.push((file, path, text));
+                }
+
+                let change = VfsChange::AddRoot {
+                    root,
+                    files: cur_files,
+                };
+                self.pending_changes.push(change);
+            }
+            TaskResult::AddSingleFile { root, path, text } => {
+                if self.find_file(root, &path).is_none() {
+                    self.do_add_file(root, path, text, false);
+                }
+            }
+            TaskResult::ChangeSingleFile { root, path, text } => {
+                if let Some(file) = self.find_file(root, &path) {
+                    self.do_change_file(file, text, false);
+                } else {
+                    self.do_add_file(root, path, text, false);
+                }
+            }
+            TaskResult::RemoveSingleFile { root, path } => {
+                if let Some(file) = self.find_file(root, &path) {
+                    self.do_remove_file(root, path, file, false);
+                }
             }
-            let text = Arc::new(text);
-            let file = self.add_file(task.root, path.clone(), Arc::clone(&text));
-            files.push((file, path, text));
         }
+    }
 
-        let change = VfsChange::AddRoot {
-            root: task.root,
-            files,
-        };
-        self.pending_changes.push(change);
+    fn do_add_file(
+        &mut self,
+        root: VfsRoot,
+        path: RelativePathBuf,
+        text: String,
+        is_overlay: bool,
+    ) -> Option<VfsFile> {
+        let text = Arc::new(text);
+        let file = self.add_file(root, path.clone(), text.clone(), is_overlay);
+        self.pending_changes.push(VfsChange::AddFile {
+            file,
+            root,
+            path,
+            text,
+        });
+        Some(file)
+    }
+
+    fn do_change_file(&mut self, file: VfsFile, text: String, is_overlay: bool) {
+        if !is_overlay && self.files[file].is_overlayed {
+            return;
+        }
+        let text = Arc::new(text);
+        self.change_file(file, text.clone(), is_overlay);
+        self.pending_changes
+            .push(VfsChange::ChangeFile { file, text });
+    }
+
+    fn do_remove_file(
+        &mut self,
+        root: VfsRoot,
+        path: RelativePathBuf,
+        file: VfsFile,
+        is_overlay: bool,
+    ) {
+        if !is_overlay && self.files[file].is_overlayed {
+            return;
+        }
+        self.remove_file(file);
+        self.pending_changes
+            .push(VfsChange::RemoveFile { root, path, file });
     }
 
     pub fn add_file_overlay(&mut self, path: &Path, text: String) -> Option<VfsFile> {
-        let mut res = None;
-        if let Some((root, path, file)) = self.find_root(path) {
-            let text = Arc::new(text);
-            let change = if let Some(file) = file {
-                res = Some(file);
-                self.change_file(file, Arc::clone(&text));
-                VfsChange::ChangeFile { file, text }
+        if let Some((root, rel_path, file)) = self.find_root(path) {
+            if let Some(file) = file {
+                self.do_change_file(file, text, true);
+                Some(file)
             } else {
-                let file = self.add_file(root, path.clone(), Arc::clone(&text));
-                res = Some(file);
-                VfsChange::AddFile {
-                    file,
-                    text,
-                    root,
-                    path,
-                }
-            };
-            self.pending_changes.push(change);
+                self.do_add_file(root, rel_path, text, true)
+            }
+        } else {
+            None
         }
-        res
     }
 
     pub fn change_file_overlay(&mut self, path: &Path, new_text: String) {
         if let Some((_root, _path, file)) = self.find_root(path) {
             let file = file.expect("can't change a file which wasn't added");
-            let text = Arc::new(new_text);
-            self.change_file(file, Arc::clone(&text));
-            let change = VfsChange::ChangeFile { file, text };
-            self.pending_changes.push(change);
+            self.do_change_file(file, new_text, true);
         }
     }
 
     pub fn remove_file_overlay(&mut self, path: &Path) -> Option<VfsFile> {
-        let mut res = None;
         if let Some((root, path, file)) = self.find_root(path) {
             let file = file.expect("can't remove a file which wasn't added");
-            res = Some(file);
             let full_path = path.to_path(&self.roots[root].root);
-            let change = if let Ok(text) = fs::read_to_string(&full_path) {
-                let text = Arc::new(text);
-                self.change_file(file, Arc::clone(&text));
-                VfsChange::ChangeFile { file, text }
+            if let Ok(text) = fs::read_to_string(&full_path) {
+                self.do_change_file(file, text, true);
             } else {
-                self.remove_file(file);
-                VfsChange::RemoveFile { root, file, path }
-            };
-            self.pending_changes.push(change);
+                self.do_remove_file(root, path, file, true);
+            }
+            Some(file)
+        } else {
+            None
         }
-        res
     }
 
     pub fn commit_changes(&mut self) -> Vec<VfsChange> {
@@ -267,19 +367,31 @@ impl Vfs {
 
     /// Sutdown the VFS and terminate the background watching thread.
     pub fn shutdown(self) -> thread::Result<()> {
-        let _ = self.worker.shutdown();
-        self.worker_handle.shutdown()
+        self.worker.shutdown()
     }
 
-    fn add_file(&mut self, root: VfsRoot, path: RelativePathBuf, text: Arc<String>) -> VfsFile {
-        let data = VfsFileData { root, path, text };
+    fn add_file(
+        &mut self,
+        root: VfsRoot,
+        path: RelativePathBuf,
+        text: Arc<String>,
+        is_overlayed: bool,
+    ) -> VfsFile {
+        let data = VfsFileData {
+            root,
+            path,
+            text,
+            is_overlayed,
+        };
         let file = self.files.alloc(data);
         self.root2files.get_mut(&root).unwrap().insert(file);
         file
     }
 
-    fn change_file(&mut self, file: VfsFile, new_text: Arc<String>) {
-        self.files[file].text = new_text;
+    fn change_file(&mut self, file: VfsFile, new_text: Arc<String>, is_overlayed: bool) {
+        let mut file_data = &mut self.files[file];
+        file_data.text = new_text;
+        file_data.is_overlayed = is_overlayed;
     }
 
     fn remove_file(&mut self, file: VfsFile) {
@@ -292,15 +404,16 @@ impl Vfs {
     }
 
     fn find_root(&self, path: &Path) -> Option<(VfsRoot, RelativePathBuf, Option<VfsFile>)> {
-        let (root, path) = self
-            .roots
-            .iter()
-            .find_map(|(root, data)| data.can_contain(path).map(|it| (root, it)))?;
-        let file = self.root2files[&root]
+        let (root, path) = self.roots.find(&path)?;
+        let file = self.find_file(root, &path);
+        Some((root, path, file))
+    }
+
+    fn find_file(&self, root: VfsRoot, path: &RelativePath) -> Option<VfsFile> {
+        self.root2files[&root]
             .iter()
             .map(|&it| it)
-            .find(|&file| self.files[file].path == path);
-        Some((root, path, file))
+            .find(|&file| self.files[file].path == path)
     }
 }
 
diff --git a/crates/ra_vfs/tests/vfs.rs b/crates/ra_vfs/tests/vfs.rs
index f56fc4603..545e1dbdd 100644
--- a/crates/ra_vfs/tests/vfs.rs
+++ b/crates/ra_vfs/tests/vfs.rs
@@ -1,24 +1,47 @@
-use std::{
-    fs,
-    collections::HashSet,
-};
+use std::{collections::HashSet, fs, time::Duration};
 
+// use flexi_logger::Logger;
+use crossbeam_channel::RecvTimeoutError;
+use ra_vfs::{Vfs, VfsChange};
 use tempfile::tempdir;
 
-use ra_vfs::{Vfs, VfsChange};
+fn process_tasks(vfs: &mut Vfs, num_tasks: u32) {
+    for _ in 0..num_tasks {
+        let task = vfs
+            .task_receiver()
+            .recv_timeout(Duration::from_secs(3))
+            .unwrap();
+        log::debug!("{:?}", task);
+        vfs.handle_task(task);
+    }
+}
+
+macro_rules! assert_match {
+    ($x:expr, $pat:pat) => {
+        assert_match!($x, $pat, ())
+    };
+    ($x:expr, $pat:pat, $assert:expr) => {
+        match $x {
+            $pat => $assert,
+            x => assert!(false, "Expected {}, got {:?}", stringify!($pat), x),
+        };
+    };
+}
 
 #[test]
 fn test_vfs_works() -> std::io::Result<()> {
+    // Logger::with_str("vfs=debug,ra_vfs=debug").start().unwrap();
+
     let files = [
         ("a/foo.rs", "hello"),
         ("a/bar.rs", "world"),
         ("a/b/baz.rs", "nested hello"),
     ];
 
-    let dir = tempdir()?;
+    let dir = tempdir().unwrap();
     for (path, text) in files.iter() {
         let file_path = dir.path().join(path);
-        fs::create_dir_all(file_path.parent().unwrap())?;
+        fs::create_dir_all(file_path.parent().unwrap()).unwrap();
         fs::write(file_path, text)?
     }
 
@@ -26,10 +49,7 @@ fn test_vfs_works() -> std::io::Result<()> {
     let b_root = dir.path().join("a/b");
 
     let (mut vfs, _) = Vfs::new(vec![a_root, b_root]);
-    for _ in 0..2 {
-        let task = vfs.task_receiver().recv().unwrap();
-        vfs.handle_task(task);
-    }
+    process_tasks(&mut vfs, 2);
     {
         let files = vfs
             .commit_changes()
@@ -58,44 +78,114 @@ fn test_vfs_works() -> std::io::Result<()> {
         assert_eq!(files, expected_files);
     }
 
-    vfs.add_file_overlay(&dir.path().join("a/b/baz.rs"), "quux".to_string());
-    let change = vfs.commit_changes().pop().unwrap();
-    match change {
-        VfsChange::ChangeFile { text, .. } => assert_eq!(&*text, "quux"),
-        _ => panic!("unexpected change"),
-    }
+    fs::write(&dir.path().join("a/b/baz.rs"), "quux").unwrap();
+    process_tasks(&mut vfs, 1);
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::ChangeFile { text, .. }],
+        assert_eq!(text.as_str(), "quux")
+    );
 
-    vfs.change_file_overlay(&dir.path().join("a/b/baz.rs"), "m".to_string());
-    let change = vfs.commit_changes().pop().unwrap();
-    match change {
-        VfsChange::ChangeFile { text, .. } => assert_eq!(&*text, "m"),
-        _ => panic!("unexpected change"),
-    }
+    vfs.add_file_overlay(&dir.path().join("a/b/baz.rs"), "m".to_string());
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::ChangeFile { text, .. }],
+        assert_eq!(text.as_str(), "m")
+    );
 
+    // changing file on disk while overlayed doesn't generate a VfsChange
+    fs::write(&dir.path().join("a/b/baz.rs"), "corge").unwrap();
+    process_tasks(&mut vfs, 1);
+    assert_match!(vfs.commit_changes().as_slice(), []);
+
+    // removing overlay restores data on disk
     vfs.remove_file_overlay(&dir.path().join("a/b/baz.rs"));
-    let change = vfs.commit_changes().pop().unwrap();
-    match change {
-        VfsChange::ChangeFile { text, .. } => assert_eq!(&*text, "nested hello"),
-        _ => panic!("unexpected change"),
-    }
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::ChangeFile { text, .. }],
+        assert_eq!(text.as_str(), "corge")
+    );
 
     vfs.add_file_overlay(&dir.path().join("a/b/spam.rs"), "spam".to_string());
-    let change = vfs.commit_changes().pop().unwrap();
-    match change {
-        VfsChange::AddFile { text, path, .. } => {
-            assert_eq!(&*text, "spam");
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::AddFile { text, path, .. }],
+        {
+            assert_eq!(text.as_str(), "spam");
             assert_eq!(path, "spam.rs");
         }
-        _ => panic!("unexpected change"),
-    }
+    );
 
     vfs.remove_file_overlay(&dir.path().join("a/b/spam.rs"));
-    let change = vfs.commit_changes().pop().unwrap();
-    match change {
-        VfsChange::RemoveFile { .. } => (),
-        _ => panic!("unexpected change"),
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::RemoveFile { path, .. }],
+        assert_eq!(path, "spam.rs")
+    );
+
+    fs::create_dir_all(dir.path().join("a/sub1/sub2")).unwrap();
+    fs::write(dir.path().join("a/sub1/sub2/new.rs"), "new hello").unwrap();
+    process_tasks(&mut vfs, 1);
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::AddFile { text, path, .. }],
+        {
+            assert_eq!(text.as_str(), "new hello");
+            assert_eq!(path, "sub1/sub2/new.rs");
+        }
+    );
+
+    fs::rename(
+        &dir.path().join("a/sub1/sub2/new.rs"),
+        &dir.path().join("a/sub1/sub2/new1.rs"),
+    )
+    .unwrap();
+    process_tasks(&mut vfs, 2);
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::RemoveFile {
+            path: removed_path, ..
+        }, VfsChange::AddFile {
+            text,
+            path: added_path,
+            ..
+        }],
+        {
+            assert_eq!(removed_path, "sub1/sub2/new.rs");
+            assert_eq!(added_path, "sub1/sub2/new1.rs");
+            assert_eq!(text.as_str(), "new hello");
+        }
+    );
+
+    fs::remove_file(&dir.path().join("a/sub1/sub2/new1.rs")).unwrap();
+    process_tasks(&mut vfs, 1);
+    assert_match!(
+        vfs.commit_changes().as_slice(),
+        [VfsChange::RemoveFile { path, .. }],
+        assert_eq!(path, "sub1/sub2/new1.rs")
+    );
+
+    {
+        vfs.add_file_overlay(&dir.path().join("a/memfile.rs"), "memfile".to_string());
+        assert_match!(
+            vfs.commit_changes().as_slice(),
+            [VfsChange::AddFile { text, .. }],
+            assert_eq!(text.as_str(), "memfile")
+        );
+        fs::write(&dir.path().join("a/memfile.rs"), "ignore me").unwrap();
+        process_tasks(&mut vfs, 1);
+        assert_match!(vfs.commit_changes().as_slice(), []);
     }
 
+    // should be ignored
+    fs::create_dir_all(dir.path().join("a/target")).unwrap();
+    fs::write(&dir.path().join("a/target/new.rs"), "ignore me").unwrap();
+
+    assert_match!(
+        vfs.task_receiver().recv_timeout(Duration::from_millis(300)), // slightly more than watcher debounce delay
+        Err(RecvTimeoutError::Timeout)
+    );
+
     vfs.shutdown().unwrap();
     Ok(())
 }