1 files changed, 0 insertions, 108 deletions

diff --git a/crates/ra_vfs/src/roots.rs b/crates/ra_vfs/src/roots.rs
deleted file mode 100644
index 4503458ee..000000000
--- a/crates/ra_vfs/src/roots.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-use std::{
-    iter,
-    path::{Path, PathBuf},
-};
-
-use relative_path::{ RelativePath, RelativePathBuf};
-
-/// VfsRoot identifies a watched directory on the file system.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct VfsRoot(pub u32);
-
-/// Describes the contents of a single source root.
-///
-/// `RootConfig` can be thought of as a glob pattern like `src/**.rs` which
-/// specifies the source root or as a function which takes a `PathBuf` and
-/// returns `true` iff path belongs to the source root
-struct RootData {
-    path: PathBuf,
-    // result of `root.canonicalize()` if that differs from `root`; `None` otherwise.
-    canonical_path: Option<PathBuf>,
-    excluded_dirs: Vec<RelativePathBuf>,
-}
-
-pub(crate) struct Roots {
-    roots: Vec<RootData>,
-}
-
-impl Roots {
-    pub(crate) fn new(mut paths: Vec<PathBuf>) -> Roots {
-        let mut roots = Vec::new();
-        // A hack to make nesting work.
-        paths.sort_by_key(|it| std::cmp::Reverse(it.as_os_str().len()));
-        paths.dedup();
-        for (i, path) in paths.iter().enumerate() {
-            let nested_roots =
-                paths[..i].iter().filter_map(|it| rel_path(path, it)).collect::<Vec<_>>();
-
-            roots.push(RootData::new(path.clone(), nested_roots));
-        }
-        Roots { roots }
-    }
-    pub(crate) fn find(&self, path: &Path) -> Option<(VfsRoot, RelativePathBuf)> {
-        self.iter().find_map(|root| {
-            let rel_path = self.contains(root, path)?;
-            Some((root, rel_path))
-        })
-    }
-    pub(crate) fn len(&self) -> usize {
-        self.roots.len()
-    }
-    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = VfsRoot> + 'a {
-        (0..self.roots.len()).into_iter().map(|idx| VfsRoot(idx as u32))
-    }
-    pub(crate) fn path(&self, root: VfsRoot) -> &Path {
-        self.root(root).path.as_path()
-    }
-    /// Checks if root contains a path and returns a root-relative path.
-    pub(crate) fn contains(&self, root: VfsRoot, path: &Path) -> Option<RelativePathBuf> {
-        let data = self.root(root);
-        iter::once(&data.path)
-            .chain(data.canonical_path.as_ref().into_iter())
-            .find_map(|base| rel_path(base, path))
-            .filter(|path| !data.excluded_dirs.contains(path))
-            .filter(|path| !data.is_excluded(path))
-    }
-
-    fn root(&self, root: VfsRoot) -> &RootData {
-        &self.roots[root.0 as usize]
-    }
-}
-
-impl RootData {
-    fn new(path: PathBuf, excluded_dirs: Vec<RelativePathBuf>) -> RootData {
-        let mut canonical_path = path.canonicalize().ok();
-        if Some(&path) == canonical_path.as_ref() {
-            canonical_path = None;
-        }
-        RootData { path, canonical_path, excluded_dirs }
-    }
-
-    fn is_excluded(&self, path: &RelativePath) -> bool {
-        if self.excluded_dirs.iter().any(|it| it == path) {
-            return true;
-        }
-        // Ignore some common directories.
-        //
-        // FIXME: don't hard-code, specify at source-root creation time using
-        // gitignore
-        for (i, c) in path.components().enumerate() {
-            if let relative_path::Component::Normal(c) = c {
-                if (i == 0 && c == "target") || c == ".git" || c == "node_modules" {
-                    return true;
-                }
-            }
-        }
-
-        match path.extension() {
-            None | Some("rs") => false,
-            _ => true,
-        }
-    }
-}
-
-fn rel_path(base: &Path, path: &Path) -> Option<RelativePathBuf> {
-    let path = path.strip_prefix(base).ok()?;
-    let path = RelativePathBuf::from_path(path).unwrap();
-    Some(path)
-}