5 files changed, 112 insertions, 141 deletions

diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 7dc721f7e..d0ddeafe7 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -2,9 +2,8 @@
 //!
 //! Files which do not belong to any explicitly configured `FileSet` belong to
 //! the default `FileSet`.
-use std::{cmp, fmt, iter};
+use std::{fmt, iter};
 
-use paths::AbsPathBuf;
 use rustc_hash::FxHashMap;
 
 use crate::{FileId, Vfs, VfsPath};
@@ -19,7 +18,7 @@ impl FileSet {
     pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
         let mut base = self.paths[&anchor].clone();
         base.pop();
-        let path = base.join(path);
+        let path = base.join(path)?;
         let res = self.files.get(&path).copied();
         res
     }
@@ -41,7 +40,13 @@ impl fmt::Debug for FileSet {
 #[derive(Debug)]
 pub struct FileSetConfig {
     n_file_sets: usize,
-    roots: Vec<(AbsPathBuf, usize)>,
+    roots: Vec<(VfsPath, usize)>,
+}
+
+impl Default for FileSetConfig {
+    fn default() -> Self {
+        FileSetConfig::builder().build()
+    }
 }
 
 impl FileSetConfig {
@@ -60,19 +65,20 @@ impl FileSetConfig {
         self.n_file_sets
     }
     fn classify(&self, path: &VfsPath) -> usize {
-        for (root, idx) in self.roots.iter() {
-            if let Some(path) = path.as_path() {
-                if path.starts_with(root) {
-                    return *idx;
-                }
-            }
+        let idx = match self.roots.binary_search_by(|(p, _)| p.cmp(path)) {
+            Ok(it) => it,
+            Err(it) => it.saturating_sub(1),
+        };
+        if path.starts_with(&self.roots[idx].0) {
+            self.roots[idx].1
+        } else {
+            self.len() - 1
         }
-        self.len() - 1
     }
 }
 
 pub struct FileSetConfigBuilder {
-    roots: Vec<Vec<AbsPathBuf>>,
+    roots: Vec<Vec<VfsPath>>,
 }
 
 impl Default for FileSetConfigBuilder {
@@ -82,18 +88,21 @@ impl Default for FileSetConfigBuilder {
 }
 
 impl FileSetConfigBuilder {
-    pub fn add_file_set(&mut self, roots: Vec<AbsPathBuf>) {
+    pub fn len(&self) -> usize {
+        self.roots.len()
+    }
+    pub fn add_file_set(&mut self, roots: Vec<VfsPath>) {
         self.roots.push(roots)
     }
     pub fn build(self) -> FileSetConfig {
         let n_file_sets = self.roots.len() + 1;
-        let mut roots: Vec<(AbsPathBuf, usize)> = self
+        let mut roots: Vec<(VfsPath, usize)> = self
             .roots
             .into_iter()
             .enumerate()
             .flat_map(|(i, paths)| paths.into_iter().zip(iter::repeat(i)))
             .collect();
-        roots.sort_by_key(|(path, _)| cmp::Reverse(path.to_string_lossy().len()));
+        roots.sort();
         FileSetConfig { n_file_sets, roots }
     }
 }
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index 75ce61cf9..024e58018 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -38,7 +38,6 @@ mod vfs_path;
 mod path_interner;
 pub mod file_set;
 pub mod loader;
-pub mod walkdir_loader;
 
 use std::{fmt, mem};
 
@@ -79,6 +78,9 @@ pub enum ChangeKind {
 }
 
 impl Vfs {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
     pub fn file_id(&self, path: &VfsPath) -> Option<FileId> {
         self.interner.get(path).filter(|&it| self.get(it).is_some())
     }
diff --git a/crates/vfs/src/loader.rs b/crates/vfs/src/loader.rs
index 5a0ca68f3..6de2e5b3f 100644
--- a/crates/vfs/src/loader.rs
+++ b/crates/vfs/src/loader.rs
@@ -1,21 +1,22 @@
 //! Object safe interface for file watching and reading.
 use std::fmt;
 
-use paths::AbsPathBuf;
+use paths::{AbsPath, AbsPathBuf};
 
+#[derive(Debug)]
 pub enum Entry {
     Files(Vec<AbsPathBuf>),
-    Directory { path: AbsPathBuf, globs: Vec<String> },
+    Directory { path: AbsPathBuf, include: Vec<String> },
 }
 
+#[derive(Debug)]
 pub struct Config {
     pub load: Vec<Entry>,
     pub watch: Vec<usize>,
 }
 
 pub enum Message {
-    DidSwitchConfig { n_entries: usize },
-    DidLoadAllEntries,
+    Progress { n_total: usize, n_done: usize },
     Loaded { files: Vec<(AbsPathBuf, Option<Vec<u8>>)> },
 }
 
@@ -27,20 +28,20 @@ pub trait Handle: fmt::Debug {
         Self: Sized;
     fn set_config(&mut self, config: Config);
     fn invalidate(&mut self, path: AbsPathBuf);
-    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>>;
+    fn load_sync(&mut self, path: &AbsPath) -> Option<Vec<u8>>;
 }
 
 impl Entry {
     pub fn rs_files_recursively(base: AbsPathBuf) -> Entry {
-        Entry::Directory { path: base, globs: globs(&["*.rs"]) }
+        Entry::Directory { path: base, include: globs(&["*.rs", "!/.git/"]) }
     }
     pub fn local_cargo_package(base: AbsPathBuf) -> Entry {
-        Entry::Directory { path: base, globs: globs(&["*.rs", "!/target/"]) }
+        Entry::Directory { path: base, include: globs(&["*.rs", "!/target/", "!/.git/"]) }
     }
     pub fn cargo_package_dependency(base: AbsPathBuf) -> Entry {
         Entry::Directory {
             path: base,
-            globs: globs(&["*.rs", "!/tests/", "!/examples/", "!/benches/"]),
+            include: globs(&["*.rs", "!/tests/", "!/examples/", "!/benches/", "!/.git/"]),
         }
     }
 }
@@ -55,10 +56,11 @@ impl fmt::Debug for Message {
             Message::Loaded { files } => {
                 f.debug_struct("Loaded").field("n_files", &files.len()).finish()
             }
-            Message::DidSwitchConfig { n_entries } => {
-                f.debug_struct("DidSwitchConfig").field("n_entries", n_entries).finish()
-            }
-            Message::DidLoadAllEntries => f.debug_struct("DidLoadAllEntries").finish(),
+            Message::Progress { n_total, n_done } => f
+                .debug_struct("Progress")
+                .field("n_total", n_total)
+                .field("n_done", n_done)
+                .finish(),
         }
     }
 }
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index de5dc0bf3..dc3031ada 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -5,38 +5,60 @@ use paths::{AbsPath, AbsPathBuf};
 
 /// Long-term, we want to support files which do not reside in the file-system,
 /// so we treat VfsPaths as opaque identifiers.
-#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct VfsPath(VfsPathRepr);
 
 impl VfsPath {
+    /// Creates an "in-memory" path from `/`-separates string.
+    /// This is most useful for testing, to avoid windows/linux differences
+    pub fn new_virtual_path(path: String) -> VfsPath {
+        assert!(path.starts_with('/'));
+        VfsPath(VfsPathRepr::VirtualPath(VirtualPath(path)))
+    }
+
     pub fn as_path(&self) -> Option<&AbsPath> {
         match &self.0 {
             VfsPathRepr::PathBuf(it) => Some(it.as_path()),
+            VfsPathRepr::VirtualPath(_) => None,
         }
     }
-    pub fn join(&self, path: &str) -> VfsPath {
+    pub fn join(&self, path: &str) -> Option<VfsPath> {
         match &self.0 {
             VfsPathRepr::PathBuf(it) => {
                 let res = it.join(path).normalize();
-                VfsPath(VfsPathRepr::PathBuf(res))
+                Some(VfsPath(VfsPathRepr::PathBuf(res)))
+            }
+            VfsPathRepr::VirtualPath(it) => {
+                let res = it.join(path)?;
+                Some(VfsPath(VfsPathRepr::VirtualPath(res)))
             }
         }
     }
     pub fn pop(&mut self) -> bool {
         match &mut self.0 {
             VfsPathRepr::PathBuf(it) => it.pop(),
+            VfsPathRepr::VirtualPath(it) => it.pop(),
+        }
+    }
+    pub fn starts_with(&self, other: &VfsPath) -> bool {
+        match (&self.0, &other.0) {
+            (VfsPathRepr::PathBuf(lhs), VfsPathRepr::PathBuf(rhs)) => lhs.starts_with(rhs),
+            (VfsPathRepr::PathBuf(_), _) => false,
+            (VfsPathRepr::VirtualPath(lhs), VfsPathRepr::VirtualPath(rhs)) => lhs.starts_with(rhs),
+            (VfsPathRepr::VirtualPath(_), _) => false,
         }
     }
 }
 
-#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 enum VfsPathRepr {
     PathBuf(AbsPathBuf),
+    VirtualPath(VirtualPath),
 }
 
 impl From<AbsPathBuf> for VfsPath {
     fn from(v: AbsPathBuf) -> Self {
-        VfsPath(VfsPathRepr::PathBuf(v))
+        VfsPath(VfsPathRepr::PathBuf(v.normalize()))
     }
 }
 
@@ -44,6 +66,50 @@ impl fmt::Display for VfsPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.0 {
             VfsPathRepr::PathBuf(it) => fmt::Display::fmt(&it.display(), f),
+            VfsPathRepr::VirtualPath(VirtualPath(it)) => fmt::Display::fmt(it, f),
+        }
+    }
+}
+
+impl fmt::Debug for VfsPath {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Debug for VfsPathRepr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self {
+            VfsPathRepr::PathBuf(it) => fmt::Debug::fmt(&it.display(), f),
+            VfsPathRepr::VirtualPath(VirtualPath(it)) => fmt::Debug::fmt(&it, f),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+struct VirtualPath(String);
+
+impl VirtualPath {
+    fn starts_with(&self, other: &VirtualPath) -> bool {
+        self.0.starts_with(&other.0)
+    }
+    fn pop(&mut self) -> bool {
+        let pos = match self.0.rfind('/') {
+            Some(pos) => pos,
+            None => return false,
+        };
+        self.0 = self.0[..pos].to_string();
+        true
+    }
+    fn join(&self, mut path: &str) -> Option<VirtualPath> {
+        let mut res = self.clone();
+        while path.starts_with("../") {
+            if !res.pop() {
+                return None;
+            }
+            path = &path["../".len()..]
         }
+        res.0 = format!("{}/{}", res.0, path);
+        Some(res)
     }
 }
diff --git a/crates/vfs/src/walkdir_loader.rs b/crates/vfs/src/walkdir_loader.rs
deleted file mode 100644
index 13e59e3f3..000000000
--- a/crates/vfs/src/walkdir_loader.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-//! A walkdir-based implementation of `loader::Handle`, which doesn't try to
-//! watch files.
-use std::convert::TryFrom;
-
-use globset::{Glob, GlobSetBuilder};
-use paths::{AbsPath, AbsPathBuf};
-use walkdir::WalkDir;
-
-use crate::loader;
-
-#[derive(Debug)]
-pub struct WalkdirLoaderHandle {
-    // Relative order of fields below is significant.
-    sender: crossbeam_channel::Sender<Message>,
-    _thread: jod_thread::JoinHandle,
-}
-
-enum Message {
-    Config(loader::Config),
-    Invalidate(AbsPathBuf),
-}
-
-impl loader::Handle for WalkdirLoaderHandle {
-    fn spawn(sender: loader::Sender) -> WalkdirLoaderHandle {
-        let actor = WalkdirLoaderActor { sender };
-        let (sender, receiver) = crossbeam_channel::unbounded::<Message>();
-        let thread = jod_thread::spawn(move || actor.run(receiver));
-        WalkdirLoaderHandle { sender, _thread: thread }
-    }
-    fn set_config(&mut self, config: loader::Config) {
-        self.sender.send(Message::Config(config)).unwrap()
-    }
-    fn invalidate(&mut self, path: AbsPathBuf) {
-        self.sender.send(Message::Invalidate(path)).unwrap();
-    }
-    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>> {
-        read(path)
-    }
-}
-
-struct WalkdirLoaderActor {
-    sender: loader::Sender,
-}
-
-impl WalkdirLoaderActor {
-    fn run(mut self, receiver: crossbeam_channel::Receiver<Message>) {
-        for msg in receiver {
-            match msg {
-                Message::Config(config) => {
-                    self.send(loader::Message::DidSwitchConfig { n_entries: config.load.len() });
-                    for entry in config.load.into_iter() {
-                        let files = self.load_entry(entry);
-                        self.send(loader::Message::Loaded { files });
-                    }
-                    drop(config.watch);
-                    self.send(loader::Message::DidLoadAllEntries);
-                }
-                Message::Invalidate(path) => {
-                    let contents = read(path.as_path());
-                    let files = vec![(path, contents)];
-                    self.send(loader::Message::Loaded { files });
-                }
-            }
-        }
-    }
-    fn load_entry(&mut self, entry: loader::Entry) -> Vec<(AbsPathBuf, Option<Vec<u8>>)> {
-        match entry {
-            loader::Entry::Files(files) => files
-                .into_iter()
-                .map(|file| {
-                    let contents = read(file.as_path());
-                    (file, contents)
-                })
-                .collect::<Vec<_>>(),
-            loader::Entry::Directory { path, globs } => {
-                let globset = {
-                    let mut builder = GlobSetBuilder::new();
-                    for glob in &globs {
-                        builder.add(Glob::new(glob).unwrap());
-                    }
-                    builder.build().unwrap()
-                };
-
-                let files = WalkDir::new(path)
-                    .into_iter()
-                    .filter_map(|it| it.ok())
-                    .filter(|it| it.file_type().is_file())
-                    .map(|it| it.into_path())
-                    .map(|it| AbsPathBuf::try_from(it).unwrap())
-                    .filter(|it| globset.is_match(&it));
-
-                files
-                    .map(|file| {
-                        let contents = read(file.as_path());
-                        (file, contents)
-                    })
-                    .collect()
-            }
-        }
-    }
-    fn send(&mut self, msg: loader::Message) {
-        (self.sender)(msg)
-    }
-}
-
-fn read(path: &AbsPath) -> Option<Vec<u8>> {
-    std::fs::read(path).ok()
-}