3 files changed, 281 insertions, 336 deletions

diff --git a/crates/ra_vfs/src/io.rs b/crates/ra_vfs/src/io.rs
index 7ca1e9835..d764c534a 100644
--- a/crates/ra_vfs/src/io.rs
+++ b/crates/ra_vfs/src/io.rs
@@ -1,19 +1,22 @@
-use std::{fs, sync::Arc, thread};
-
-use crossbeam_channel::{Receiver, Sender};
+use std::{
+    fs,
+    thread,
+    path::{Path, PathBuf},
+    sync::{mpsc, Arc},
+    time::Duration,
+};
+use crossbeam_channel::{Receiver, Sender, unbounded, RecvError, select};
 use relative_path::RelativePathBuf;
 use thread_worker::WorkerHandle;
 use walkdir::WalkDir;
+use notify::{DebouncedEvent, RecommendedWatcher, RecursiveMode, Watcher as _Watcher};
 
-mod watcher;
-use watcher::Watcher;
-
-use crate::{RootFilter, Roots, VfsRoot};
+use crate::{RootConfig, Roots, VfsRoot};
 
 pub(crate) enum Task {
     AddRoot {
         root: VfsRoot,
-        filter: Arc<RootFilter>,
+        config: Arc<RootConfig>,
     },
 }
 
@@ -39,6 +42,15 @@ pub enum TaskResult {
     },
 }
 
+#[derive(Debug)]
+enum ChangeKind {
+    Create,
+    Write,
+    Remove,
+}
+
+const WATCHER_DELAY: Duration = Duration::from_millis(250);
+
 pub(crate) struct Worker {
     worker: thread_worker::Worker<Task, TaskResult>,
     worker_handle: WorkerHandle,
@@ -46,24 +58,75 @@ pub(crate) struct Worker {
 
 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
+        // This is a pretty elaborate setup of threads & channels! It is
+        // explained by the following concerns:
+        //    * we need to burn a thread translating from notify's mpsc to
+        //      crossbeam_channel.
+        //    * we want to read all files from a single thread, to gurantee that
+        //      we always get fresher versions and never go back in time.
+        //    * we want to tear down everything neatly during shutdown.
+        let (worker, worker_handle) = thread_worker::spawn(
+            "vfs",
+            128,
+            // This are the channels we use to communicate with outside world.
+            // If `input_receiver` is closed we need to tear ourselves down.
+            // `output_sender` should not be closed unless the parent died.
+            move |input_receiver, output_sender| {
+                // These are `std` channels notify will send events to
+                let (notify_sender, notify_receiver) = mpsc::channel();
+                // These are the corresponding crossbeam channels
+                let (watcher_sender, watcher_receiver) = unbounded();
+
+                let mut watcher = notify::watcher(notify_sender, WATCHER_DELAY)
+                    .map_err(|e| log::error!("failed to spawn notify {}", e))
+                    .ok();
+                // Start a silly thread to tranform between two channels
+                let thread = thread::spawn(move || {
+                    notify_receiver
+                        .into_iter()
+                        .for_each(|event| convert_notify_event(event, &watcher_sender))
+                });
+
+                // Process requests from the called or notifications from
+                // watcher until the caller says stop.
+                loop {
+                    select! {
+                        // Received request from the caller. If this channel is
+                        // closed, we should shutdown everything.
+                        recv(input_receiver) -> t => match t {
+                            Err(RecvError) => {
+                                drop(input_receiver);
+                                break
+                            },
+                            Ok(Task::AddRoot { root, config }) => {
+                                watch_root(watcher.as_mut(), &output_sender, root, Arc::clone(&config));
+                            }
+                        },
+                        // Watcher send us changes. If **this** channel is
+                        // closed, the watcher has died, which indicates a bug
+                        // -- escalate!
+                        recv(watcher_receiver) -> event => match event {
+                            Err(RecvError) => panic!("watcher is dead"),
+                            Ok((path, change)) => {
+                                handle_change(watcher.as_mut(), &output_sender, &*roots, path, change);
+                            }
+                        },
                     }
-                };
-                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()
-            });
+                // Stopped the watcher
+                drop(watcher.take());
+                // Drain pending events: we are not inrerested in them anyways!
+                watcher_receiver.into_iter().for_each(|_| ());
+
+                let res = thread.join();
+                match &res {
+                    Ok(()) => log::info!("... Watcher terminated with ok"),
+                    Err(_) => log::error!("... Watcher terminated with err"),
+                }
+                res.unwrap();
+            },
+        );
+
         Worker {
             worker,
             worker_handle,
@@ -84,46 +147,142 @@ impl Worker {
     }
 }
 
-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)
+fn watch_root(
+    watcher: Option<&mut RecommendedWatcher>,
+    sender: &Sender<TaskResult>,
+    root: VfsRoot,
+    config: Arc<RootConfig>,
+) {
+    log::debug!("loading {} ...", config.root.as_path().display());
+    let files = watch_recursive(watcher, config.root.as_path(), &*config)
+        .into_iter()
+        .filter_map(|path| {
+            let abs_path = path.to_path(&config.root);
+            let text = read_to_string(&abs_path)?;
+            Some((path, text))
+        })
+        .collect();
+    sender
+        .send(TaskResult::BulkLoadRoot { root, files })
+        .unwrap();
+    log::debug!("... loaded {}", config.root.as_path().display());
+}
+
+fn convert_notify_event(event: DebouncedEvent, sender: &Sender<(PathBuf, ChangeKind)>) {
+    // forward relevant events only
+    match event {
+        DebouncedEvent::NoticeWrite(_)
+        | DebouncedEvent::NoticeRemove(_)
+        | DebouncedEvent::Chmod(_) => {
+            // ignore
+        }
+        DebouncedEvent::Rescan => {
+            // TODO rescan all roots
+        }
+        DebouncedEvent::Create(path) => {
+            sender.send((path, ChangeKind::Create)).unwrap();
+        }
+        DebouncedEvent::Write(path) => {
+            sender.send((path, ChangeKind::Write)).unwrap();
+        }
+        DebouncedEvent::Remove(path) => {
+            sender.send((path, ChangeKind::Remove)).unwrap();
+        }
+        DebouncedEvent::Rename(src, dst) => {
+            sender.send((src, ChangeKind::Remove)).unwrap();
+            sender.send((dst, ChangeKind::Create)).unwrap();
+        }
+        DebouncedEvent::Error(err, path) => {
+            // TODO should we reload the file contents?
+            log::warn!("watcher error \"{}\", {:?}", err, path);
+        }
+    }
+}
+
+fn handle_change(
+    watcher: Option<&mut RecommendedWatcher>,
+    sender: &Sender<TaskResult>,
+    roots: &Roots,
+    path: PathBuf,
+    kind: ChangeKind,
+) {
+    let (root, rel_path) = match roots.find(&path) {
+        None => return,
+        Some(it) => it,
+    };
+    let config = &roots[root];
+    match kind {
+        ChangeKind::Create => {
+            let mut paths = Vec::new();
+            if path.is_dir() {
+                paths.extend(watch_recursive(watcher, &path, &config));
+            } else {
+                paths.push(rel_path);
             }
-            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 })
+            paths
+                .into_iter()
+                .filter_map(|rel_path| {
+                    let abs_path = rel_path.to_path(&config.root);
+                    let text = read_to_string(&abs_path)?;
+                    Some((rel_path, text))
+                })
+                .try_for_each(|(path, text)| {
+                    sender.send(TaskResult::AddSingleFile { root, path, text })
+                })
+                .unwrap()
         }
+        ChangeKind::Write => {
+            if let Some(text) = read_to_string(&path) {
+                sender
+                    .send(TaskResult::ChangeSingleFile {
+                        root,
+                        path: rel_path,
+                        text,
+                    })
+                    .unwrap();
+            }
+        }
+        ChangeKind::Remove => sender
+            .send(TaskResult::RemoveSingleFile {
+                root,
+                path: rel_path,
+            })
+            .unwrap(),
     }
 }
 
-fn load_root(filter: &RootFilter) -> Vec<(RelativePathBuf, String)> {
-    let mut res = Vec::new();
-    for entry in WalkDir::new(&filter.root)
+fn watch_recursive(
+    mut watcher: Option<&mut RecommendedWatcher>,
+    dir: &Path,
+    config: &RootConfig,
+) -> Vec<RelativePathBuf> {
+    let mut files = Vec::new();
+    for entry in WalkDir::new(dir)
         .into_iter()
-        .filter_entry(filter.entry_filter())
+        .filter_entry(|it| config.contains(it.path()).is_some())
+        .filter_map(|it| it.map_err(|e| log::warn!("watcher error: {}", e)).ok())
     {
-        let entry = match entry {
-            Ok(entry) => entry,
-            Err(e) => {
-                log::warn!("watcher error: {}", e);
-                continue;
+        if entry.file_type().is_dir() {
+            if let Some(watcher) = &mut watcher {
+                watch_one(watcher, entry.path());
             }
-        };
-        if !entry.file_type().is_file() {
-            continue;
+        } else {
+            let path = config.contains(entry.path()).unwrap();
+            files.push(path.to_owned());
         }
-        let path = entry.path();
-        let text = match fs::read_to_string(path) {
-            Ok(text) => text,
-            Err(e) => {
-                log::warn!("watcher error: {}", e);
-                continue;
-            }
-        };
-        let path = RelativePathBuf::from_path(path.strip_prefix(&filter.root).unwrap()).unwrap();
-        res.push((path.to_owned(), text))
     }
-    res
+    files
+}
+
+fn watch_one(watcher: &mut RecommendedWatcher, dir: &Path) {
+    match watcher.watch(dir, RecursiveMode::NonRecursive) {
+        Ok(()) => log::debug!("watching \"{}\"", dir.display()),
+        Err(e) => log::warn!("could not watch \"{}\": {}", dir.display(), e),
+    }
+}
+
+fn read_to_string(path: &Path) -> Option<String> {
+    fs::read_to_string(&path)
+        .map_err(|e| log::warn!("failed to read file {}", e))
+        .ok()
 }
diff --git a/crates/ra_vfs/src/io/watcher.rs b/crates/ra_vfs/src/io/watcher.rs
deleted file mode 100644
index ff6775f59..000000000
--- a/crates/ra_vfs/src/io/watcher.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-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 70a13f765..71a3f807d 100644
--- a/crates/ra_vfs/src/lib.rs
+++ b/crates/ra_vfs/src/lib.rs
@@ -18,94 +18,78 @@ mod io;
 use std::{
     cmp::Reverse,
     fmt, fs, mem,
-    ops::{Deref, DerefMut},
     path::{Path, PathBuf},
     sync::Arc,
     thread,
 };
 
 use crossbeam_channel::Receiver;
-use ra_arena::{impl_arena_id, Arena, RawId};
+use ra_arena::{impl_arena_id, Arena, RawId, map::ArenaMap};
 use relative_path::{Component, RelativePath, RelativePathBuf};
 use rustc_hash::{FxHashMap, FxHashSet};
-use walkdir::DirEntry;
 
 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.
-pub(crate) struct RootFilter {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct VfsRoot(pub RawId);
+impl_arena_id!(VfsRoot);
+
+/// Describes the contents of a single source root.
+///
+/// `RootConfig` can be thought of as a glob pattern like `src/**.rs` whihc
+/// specifes the source root or as a function whihc takes a `PathBuf` and
+/// returns `true` iff path belongs to the source root
+pub(crate) struct RootConfig {
     root: PathBuf,
-    filter: fn(&Path, &RelativePath) -> bool,
     excluded_dirs: Vec<PathBuf>,
 }
 
-impl RootFilter {
-    fn new(root: PathBuf, excluded_dirs: Vec<PathBuf>) -> RootFilter {
-        RootFilter {
+pub(crate) struct Roots {
+    roots: Arena<VfsRoot, Arc<RootConfig>>,
+}
+
+impl std::ops::Deref for Roots {
+    type Target = Arena<VfsRoot, Arc<RootConfig>>;
+    fn deref(&self) -> &Self::Target {
+        &self.roots
+    }
+}
+
+impl RootConfig {
+    fn new(root: PathBuf, excluded_dirs: Vec<PathBuf>) -> RootConfig {
+        RootConfig {
             root,
-            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.
-    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()) {
+    /// Cheks if root contains a path and returns a root-relative path.
+    pub(crate) fn contains(&self, path: &Path) -> Option<RelativePathBuf> {
+        // First, check excluded dirs
+        if self.excluded_dirs.iter().any(|it| path.starts_with(it)) {
             return None;
         }
-        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()
-            }
-        }
-    }
-}
+        let rel_path = path.strip_prefix(&self.root).ok()?;
+        let rel_path = RelativePathBuf::from_path(rel_path).ok()?;
 
-pub(crate) fn default_filter(path: &Path, rel_path: &RelativePath) -> bool {
-    if path.is_dir() {
+        // Ignore some common directories.
+        //
+        // FIXME: don't hard-code, specify at source-root creation time using
+        // gitignore
         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;
+                    return None;
                 }
             }
         }
-        true
-    } else {
-        rel_path.extension() == Some("rs")
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct VfsRoot(pub RawId);
-impl_arena_id!(VfsRoot);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct VfsFile(pub RawId);
-impl_arena_id!(VfsFile);
 
-struct VfsFileData {
-    root: VfsRoot,
-    path: RelativePathBuf,
-    is_overlayed: bool,
-    text: Arc<String>,
-}
+        if path.is_file() && rel_path.extension() != Some("rs") {
+            return None;
+        }
 
-pub(crate) struct Roots {
-    roots: Arena<VfsRoot, Arc<RootFilter>>,
+        Some(rel_path)
+    }
 }
 
 impl Roots {
@@ -120,59 +104,61 @@ impl Roots {
                 .map(|it| it.clone())
                 .collect::<Vec<_>>();
 
-            let root_filter = Arc::new(RootFilter::new(path.clone(), nested_roots));
+            let config = Arc::new(RootConfig::new(path.clone(), nested_roots));
 
-            roots.alloc(root_filter.clone());
+            roots.alloc(config.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)))
+            .find_map(|(root, data)| data.contains(path).map(|it| (root, it)))
     }
 }
 
-impl Deref for Roots {
-    type Target = Arena<VfsRoot, Arc<RootFilter>>;
-    fn deref(&self) -> &Self::Target {
-        &self.roots
-    }
-}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct VfsFile(pub RawId);
+impl_arena_id!(VfsFile);
 
-impl DerefMut for Roots {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.roots
-    }
+struct VfsFileData {
+    root: VfsRoot,
+    path: RelativePathBuf,
+    is_overlayed: bool,
+    text: Arc<String>,
 }
 
 pub struct Vfs {
     roots: Arc<Roots>,
     files: Arena<VfsFile, VfsFileData>,
-    root2files: FxHashMap<VfsRoot, FxHashSet<VfsFile>>,
+    root2files: ArenaMap<VfsRoot, FxHashSet<VfsFile>>,
     pending_changes: Vec<VfsChange>,
     worker: Worker,
 }
 
 impl fmt::Debug for Vfs {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("Vfs { ... }")
+        f.debug_struct("Vfs")
+            .field("n_roots", &self.roots.len())
+            .field("n_files", &self.files.len())
+            .field("n_pending_changes", &self.pending_changes.len())
+            .finish()
     }
 }
 
 impl Vfs {
     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();
+        let worker = io::Worker::start(Arc::clone(&roots));
+        let mut root2files = ArenaMap::default();
 
-        for (root, filter) in roots.iter() {
+        for (root, config) in roots.iter() {
             root2files.insert(root, Default::default());
             worker
                 .sender()
                 .send(io::Task::AddRoot {
                     root,
-                    filter: filter.clone(),
+                    config: Arc::clone(config),
                 })
                 .unwrap();
         }
@@ -242,7 +228,7 @@ impl Vfs {
                 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]
+                let exising = self.root2files[root]
                     .iter()
                     .map(|&file| (self.files[file].path.clone(), file))
                     .collect::<FxHashMap<_, _>>();
@@ -384,7 +370,7 @@ impl Vfs {
             is_overlayed,
         };
         let file = self.files.alloc(data);
-        self.root2files.get_mut(&root).unwrap().insert(file);
+        self.root2files.get_mut(root).unwrap().insert(file);
         file
     }
 
@@ -399,7 +385,7 @@ impl Vfs {
         self.files[file].text = Default::default();
         self.files[file].path = Default::default();
         let root = self.files[file].root;
-        let removed = self.root2files.get_mut(&root).unwrap().remove(&file);
+        let removed = self.root2files.get_mut(root).unwrap().remove(&file);
         assert!(removed);
     }
 
@@ -410,7 +396,7 @@ impl Vfs {
     }
 
     fn find_file(&self, root: VfsRoot, path: &RelativePath) -> Option<VfsFile> {
-        self.root2files[&root]
+        self.root2files[root]
             .iter()
             .map(|&it| it)
             .find(|&file| self.files[file].path == path)