23 files changed, 267 insertions, 227 deletions

diff --git a/crates/ra_arena/src/lib.rs b/crates/ra_arena/src/lib.rs
index 3b7cb77b1..3ec8d3b60 100644
--- a/crates/ra_arena/src/lib.rs
+++ b/crates/ra_arena/src/lib.rs
@@ -79,7 +79,7 @@ impl<ID: ArenaId, T> Arena<ID, T> {
         self.data.push(value);
         ID::from_raw(id)
     }
-    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> {
+    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> + ExactSizeIterator {
         self.data.iter().enumerate().map(|(idx, value)| (ID::from_raw(RawId(idx as u32)), value))
     }
 }
diff --git a/crates/ra_batch/Cargo.toml b/crates/ra_batch/Cargo.toml
index 0ee94c445..8e23826a4 100644
--- a/crates/ra_batch/Cargo.toml
+++ b/crates/ra_batch/Cargo.toml
@@ -9,6 +9,7 @@ log = "0.4.5"
 rustc-hash = "1.0"
 
 ra_vfs = "0.2.0"
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 ra_db = { path = "../ra_db" }
 ra_ide_api = { path = "../ra_ide_api" }
 ra_hir = { path = "../ra_hir" }
diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index c25737aaa..0db751465 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -1,14 +1,12 @@
-mod vfs_filter;
-
 use std::{collections::HashSet, error::Error, path::Path};
 
 use rustc_hash::FxHashMap;
 
 use ra_db::{CrateGraph, FileId, SourceRootId};
 use ra_ide_api::{AnalysisChange, AnalysisHost};
-use ra_project_model::{ProjectRoot, ProjectWorkspace};
-use ra_vfs::{Vfs, VfsChange};
-use vfs_filter::IncludeRustFiles;
+use ra_project_model::{PackageRoot, ProjectWorkspace};
+use ra_vfs::{RootEntry, Vfs, VfsChange};
+use ra_vfs_glob::RustPackageFilterBuilder;
 
 type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
@@ -19,11 +17,23 @@ fn vfs_root_to_id(r: ra_vfs::VfsRoot) -> SourceRootId {
     SourceRootId(r.0)
 }
 
-pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId, ProjectRoot>)> {
+pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId, PackageRoot>)> {
     let root = std::env::current_dir()?.join(root);
     let ws = ProjectWorkspace::discover(root.as_ref())?;
     let project_roots = ws.to_roots();
-    let (mut vfs, roots) = Vfs::new(IncludeRustFiles::from_roots(project_roots.clone()).collect());
+    let (mut vfs, roots) = Vfs::new(
+        project_roots
+            .iter()
+            .map(|pkg_root| {
+                RootEntry::new(
+                    pkg_root.path().clone(),
+                    RustPackageFilterBuilder::default()
+                        .set_member(pkg_root.is_member())
+                        .into_vfs_filter(),
+                )
+            })
+            .collect(),
+    );
     let crate_graph = ws.to_crate_graph(&mut |path: &Path| {
         let vfs_file = vfs.load(path);
         log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
@@ -48,7 +58,7 @@ pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId,
 }
 
 pub fn load(
-    source_roots: &FxHashMap<SourceRootId, ProjectRoot>,
+    source_roots: &FxHashMap<SourceRootId, PackageRoot>,
     crate_graph: CrateGraph,
     vfs: &mut Vfs,
 ) -> AnalysisHost {
diff --git a/crates/ra_batch/src/vfs_filter.rs b/crates/ra_batch/src/vfs_filter.rs
deleted file mode 100644
index 2f0d8cb8b..000000000
--- a/crates/ra_batch/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::ProjectRoot;
-use ra_vfs::{Filter, RelativePath, RootEntry};
-use std::path::PathBuf;
-
-/// `IncludeRustFiles` is used to convert
-/// from `ProjectRoot` to `RootEntry` for VFS
-pub struct IncludeRustFiles {
-    root: ProjectRoot,
-}
-
-impl IncludeRustFiles {
-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>
-    where
-        R: IntoIterator<Item = ProjectRoot>,
-    {
-        roots.into_iter().map(IncludeRustFiles::from_root)
-    }
-
-    pub fn from_root(root: ProjectRoot) -> RootEntry {
-        IncludeRustFiles::from(root).into()
-    }
-
-    #[allow(unused)]
-    pub fn external(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, false))
-    }
-
-    pub fn member(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, true))
-    }
-}
-
-impl Filter for IncludeRustFiles {
-    fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        self.root.include_dir(dir_path)
-    }
-
-    fn include_file(&self, file_path: &RelativePath) -> bool {
-        self.root.include_file(file_path)
-    }
-}
-
-impl From<ProjectRoot> for IncludeRustFiles {
-    fn from(v: ProjectRoot) -> IncludeRustFiles {
-        IncludeRustFiles { root: v }
-    }
-}
-
-impl From<IncludeRustFiles> for RootEntry {
-    fn from(v: IncludeRustFiles) -> RootEntry {
-        let path = v.root.path().clone();
-        RootEntry::new(path, Box::new(v))
-    }
-}
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 403aab352..7e7e6c073 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -52,6 +52,9 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
     println!("Total modules found: {}", visited_modules.len());
     println!("Total declarations: {}", num_decls);
     println!("Total functions: {}", funcs.len());
+    println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+
+    let inference_time = Instant::now();
     let bar = indicatif::ProgressBar::with_draw_target(
         funcs.len() as u64,
         indicatif::ProgressDrawTarget::stderr_nohz(),
@@ -112,7 +115,8 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
         num_exprs_partially_unknown,
         (num_exprs_partially_unknown * 100 / num_exprs)
     );
-    println!("Analysis: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+    println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
+    println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
 
     if memory_usage {
         drop(db);
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index cec360667..c282d6db8 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -25,6 +25,7 @@ ra_ide_api = { path = "../ra_ide_api" }
 gen_lsp_server = { path = "../gen_lsp_server" }
 ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/init.rs b/crates/ra_lsp_server/src/config.rs
index b894b449d..6dcdc695a 100644
--- a/crates/ra_lsp_server/src/init.rs
+++ b/crates/ra_lsp_server/src/config.rs
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Deserializer};
 
 /// Client provided initialization options
-#[derive(Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", default)]
-pub struct InitializationOptions {
+pub struct ServerConfig {
     /// Whether the client supports our custom highlighting publishing decorations.
     /// This is different to the highlightingOn setting, which is whether the user
     /// wants our custom highlighting to be used.
@@ -18,14 +18,17 @@ pub struct InitializationOptions {
     #[serde(deserialize_with = "nullable_bool_true")]
     pub show_workspace_loaded: bool,
 
+    pub exclude_globs: Vec<String>,
+
     pub lru_capacity: Option<usize>,
 }
 
-impl Default for InitializationOptions {
-    fn default() -> InitializationOptions {
-        InitializationOptions {
+impl Default for ServerConfig {
+    fn default() -> ServerConfig {
+        ServerConfig {
             publish_decorations: false,
             show_workspace_loaded: true,
+            exclude_globs: Vec::new(),
             lru_capacity: None,
         }
     }
@@ -56,7 +59,7 @@ mod test {
     #[test]
     fn deserialize_init_options_defaults() {
         // check that null == default for both fields
-        let default = InitializationOptions::default();
+        let default = ServerConfig::default();
         assert_eq!(default, serde_json::from_str(r#"{}"#).unwrap());
         assert_eq!(
             default,
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 59c5e1582..df8ea6e0d 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -1,13 +1,13 @@
 use lsp_types::{
-    self, CreateFile, DocumentChangeOperation, DocumentChanges, Documentation, Location,
-    LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp, SymbolKind,
-    TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams, Url,
-    VersionedTextDocumentIdentifier, WorkspaceEdit,
+    self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
+    Location, LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp,
+    SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
+    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
 };
 use ra_ide_api::{
     translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
     FileRange, FileSystemEdit, InsertTextFormat, LineCol, LineIndex, NavigationTarget, RangeInfo,
-    SourceChange, SourceFileEdit,
+    Severity, SourceChange, SourceFileEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
@@ -79,6 +79,16 @@ impl Conv for CompletionItemKind {
     }
 }
 
+impl Conv for Severity {
+    type Output = DiagnosticSeverity;
+    fn conv(self) -> DiagnosticSeverity {
+        match self {
+            Severity::Error => DiagnosticSeverity::Error,
+            Severity::WeakWarning => DiagnosticSeverity::Hint,
+        }
+    }
+}
+
 impl ConvWith for CompletionItem {
     type Ctx = LineIndex;
     type Output = ::lsp_types::CompletionItem;
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 56a263aa5..795f86383 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -4,13 +4,11 @@ mod conv;
 mod main_loop;
 mod markdown;
 mod project_model;
-mod vfs_filter;
 pub mod req;
-pub mod init;
+pub mod config;
 mod world;
 
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 pub use crate::{
-    caps::server_capabilities, init::InitializationOptions, main_loop::main_loop,
-    main_loop::LspError,
+    caps::server_capabilities, config::ServerConfig, main_loop::main_loop, main_loop::LspError,
 };
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index c1f8243be..1a2ab1bc2 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -2,7 +2,7 @@ use flexi_logger::{Duplicate, Logger};
 use gen_lsp_server::{run_server, stdio_transport};
 use serde::Deserialize;
 
-use ra_lsp_server::{InitializationOptions, Result};
+use ra_lsp_server::{Result, ServerConfig};
 use ra_prof;
 
 fn main() -> Result<()> {
@@ -48,7 +48,7 @@ fn main_inner() -> Result<()> {
 
         let opts = params
             .initialization_options
-            .and_then(|v| InitializationOptions::deserialize(v).ok())
+            .and_then(|v| ServerConfig::deserialize(v).ok())
             .unwrap_or_default();
 
         ra_lsp_server::main_loop(workspace_roots, params.capabilities, opts, r, s)
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 8e830c8b8..9d540a87e 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -23,7 +23,7 @@ use crate::{
     project_model::workspace_loader,
     req,
     world::{Options, WorldSnapshot, WorldState},
-    InitializationOptions, Result,
+    Result, ServerConfig,
 };
 
 const THREADPOOL_SIZE: usize = 8;
@@ -52,10 +52,11 @@ impl Error for LspError {}
 pub fn main_loop(
     ws_roots: Vec<PathBuf>,
     client_caps: ClientCapabilities,
-    options: InitializationOptions,
+    config: ServerConfig,
     msg_receiver: &Receiver<RawMessage>,
     msg_sender: &Sender<RawMessage>,
 ) -> Result<()> {
+    log::debug!("server_config: {:?}", config);
     // FIXME: support dynamic workspace loading.
     let workspaces = {
         let ws_worker = workspace_loader();
@@ -77,14 +78,19 @@ pub fn main_loop(
         }
         loaded_workspaces
     };
-
+    let globs = config
+        .exclude_globs
+        .iter()
+        .map(|glob| ra_vfs_glob::Glob::new(glob))
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     let mut state = WorldState::new(
         ws_roots,
         workspaces,
-        options.lru_capacity,
+        config.lru_capacity,
+        &globs,
         Options {
-            publish_decorations: options.publish_decorations,
-            show_workspace_loaded: options.show_workspace_loaded,
+            publish_decorations: config.publish_decorations,
+            show_workspace_loaded: config.show_workspace_loaded,
             supports_location_link: client_caps
                 .text_document
                 .and_then(|it| it.definition)
@@ -269,7 +275,7 @@ fn main_loop_inner(
             && pending_libraries.is_empty()
             && in_flight_libraries == 0
         {
-            let n_packages: usize = state.workspaces.iter().map(|it| it.count()).sum();
+            let n_packages: usize = state.workspaces.iter().map(|it| it.n_packages()).sum();
             if state.options.show_workspace_loaded {
                 let msg = format!("workspace loaded, {} rust packages", n_packages);
                 show_message(req::MessageType::Info, msg, msg_sender);
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index a6dc1f964..686ee5d12 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -3,13 +3,13 @@ use std::{fmt::Write as _, io::Write as _};
 use gen_lsp_server::ErrorCode;
 use lsp_types::{
     CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
-    DiagnosticSeverity, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
-    FoldingRangeKind, FoldingRangeParams, Hover, HoverContents, Location, MarkupContent,
-    MarkupKind, Position, PrepareRenameResponse, Range, RenameParams, SymbolInformation,
-    TextDocumentIdentifier, TextEdit, WorkspaceEdit,
+    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeKind,
+    FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
+    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
+    TextEdit, WorkspaceEdit,
 };
 use ra_ide_api::{
-    AssistId, Cancelable, FileId, FilePosition, FileRange, FoldKind, Query, RunnableKind, Severity,
+    AssistId, Cancelable, FileId, FilePosition, FileRange, FoldKind, Query, RunnableKind,
 };
 use ra_prof::profile;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextUnit};
@@ -838,7 +838,7 @@ pub fn publish_diagnostics(
         .into_iter()
         .map(|d| Diagnostic {
             range: d.range.conv_with(&line_index),
-            severity: Some(to_diagnostic_severity(d.severity)),
+            severity: Some(d.severity.conv()),
             code: None,
             source: Some("rust-analyzer".to_string()),
             message: d.message,
@@ -871,15 +871,6 @@ fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>>
     Ok(res)
 }
 
-fn to_diagnostic_severity(severity: Severity) -> DiagnosticSeverity {
-    use ra_ide_api::Severity::*;
-
-    match severity {
-        Error => DiagnosticSeverity::Error,
-        WeakWarning => DiagnosticSeverity::Hint,
-    }
-}
-
 pub fn handle_inlay_hints(
     world: WorldSnapshot,
     params: InlayHintsParams,
diff --git a/crates/ra_lsp_server/src/markdown.rs b/crates/ra_lsp_server/src/markdown.rs
index 947ef77cd..c1eb0236a 100644
--- a/crates/ra_lsp_server/src/markdown.rs
+++ b/crates/ra_lsp_server/src/markdown.rs
@@ -54,4 +54,21 @@ mod tests {
         let comment = "this\nis\nultiline";
         assert_eq!(format_docs(comment), comment);
     }
+
+    #[test]
+    fn test_code_blocks_in_comments_marked_as_rust() {
+        let comment = r#"```rust
+fn main(){}
+```
+Some comment.
+```
+let a = 1;
+```"#;
+
+        assert_eq!(
+            format_docs(comment),
+            "```rust\nfn main(){}\n```\nSome comment.\n```rust\nlet a = 1;\n```"
+        );
+    }
+
 }
diff --git a/crates/ra_lsp_server/src/vfs_filter.rs b/crates/ra_lsp_server/src/vfs_filter.rs
deleted file mode 100644
index e16a57da5..000000000
--- a/crates/ra_lsp_server/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::ProjectRoot;

-use ra_vfs::{Filter, RelativePath, RootEntry};

-use std::path::PathBuf;

-

-/// `IncludeRustFiles` is used to convert

-/// from `ProjectRoot` to `RootEntry` for VFS

-pub struct IncludeRustFiles {

-    root: ProjectRoot,

-}

-

-impl IncludeRustFiles {

-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>

-    where

-        R: IntoIterator<Item = ProjectRoot>,

-    {

-        roots.into_iter().map(IncludeRustFiles::from_root)

-    }

-

-    pub fn from_root(root: ProjectRoot) -> RootEntry {

-        IncludeRustFiles::from(root).into()

-    }

-

-    #[allow(unused)]

-    pub fn external(path: PathBuf) -> RootEntry {

-        IncludeRustFiles::from_root(ProjectRoot::new(path, false))

-    }

-

-    pub fn member(path: PathBuf) -> RootEntry {

-        IncludeRustFiles::from_root(ProjectRoot::new(path, true))

-    }

-}

-

-impl Filter for IncludeRustFiles {

-    fn include_dir(&self, dir_path: &RelativePath) -> bool {

-        self.root.include_dir(dir_path)

-    }

-

-    fn include_file(&self, file_path: &RelativePath) -> bool {

-        self.root.include_file(file_path)

-    }

-}

-

-impl std::convert::From<ProjectRoot> for IncludeRustFiles {

-    fn from(v: ProjectRoot) -> IncludeRustFiles {

-        IncludeRustFiles { root: v }

-    }

-}

-

-impl std::convert::From<IncludeRustFiles> for RootEntry {

-    fn from(v: IncludeRustFiles) -> RootEntry {

-        let path = v.root.path().clone();

-        RootEntry::new(path, Box::new(v))

-    }

-}

diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 1d7755910..9990ef62e 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -9,13 +9,13 @@ use parking_lot::RwLock;
 use ra_ide_api::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
 };
-use ra_vfs::{Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs::{RootEntry, Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs_glob::{Glob, RustPackageFilterBuilder};
 use relative_path::RelativePathBuf;
 
 use crate::{
     main_loop::pending_requests::{CompletedRequest, LatestRequests},
     project_model::ProjectWorkspace,
-    vfs_filter::IncludeRustFiles,
     LspError, Result,
 };
 
@@ -56,14 +56,28 @@ impl WorldState {
         folder_roots: Vec<PathBuf>,
         workspaces: Vec<ProjectWorkspace>,
         lru_capacity: Option<usize>,
+        exclude_globs: &[Glob],
         options: Options,
     ) -> WorldState {
         let mut change = AnalysisChange::new();
 
         let mut roots = Vec::new();
-        roots.extend(folder_roots.iter().cloned().map(IncludeRustFiles::member));
+        roots.extend(folder_roots.iter().map(|path| {
+            let mut filter = RustPackageFilterBuilder::default().set_member(true);
+            for glob in exclude_globs.iter() {
+                filter = filter.exclude(glob.clone());
+            }
+            RootEntry::new(path.clone(), filter.into_vfs_filter())
+        }));
         for ws in workspaces.iter() {
-            roots.extend(IncludeRustFiles::from_roots(ws.to_roots()));
+            roots.extend(ws.to_roots().into_iter().map(|pkg_root| {
+                let mut filter =
+                    RustPackageFilterBuilder::default().set_member(pkg_root.is_member());
+                for glob in exclude_globs.iter() {
+                    filter = filter.exclude(glob.clone());
+                }
+                RootEntry::new(pkg_root.path().clone(), filter.into_vfs_filter())
+            }));
         }
 
         let (mut vfs, vfs_roots) = Vfs::new(roots);
@@ -211,7 +225,7 @@ impl WorldSnapshot {
         } else {
             res.push_str("workspaces:\n");
             for w in self.workspaces.iter() {
-                res += &format!("{} packages loaded\n", w.count());
+                res += &format!("{} packages loaded\n", w.n_packages());
             }
         }
         res.push_str("\nanalysis:\n");
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/ra_lsp_server/tests/heavy_tests/support.rs
index 5dddbbe17..ba8ee8b06 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/support.rs
@@ -22,7 +22,7 @@ use tempfile::TempDir;
 use test_utils::{find_mismatch, parse_fixture};
 use thread_worker::Worker;
 
-use ra_lsp_server::{main_loop, req, InitializationOptions};
+use ra_lsp_server::{main_loop, req, ServerConfig};
 
 pub struct Project<'a> {
     fixture: &'a str,
@@ -107,7 +107,7 @@ impl Server {
                         window: None,
                         experimental: None,
                     },
-                    InitializationOptions::default(),
+                    ServerConfig::default(),
                     &msg_receiver,
                     &msg_sender,
                 )
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 159ed50df..393586561 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -6,7 +6,7 @@ use crate::{
     event::Event,
     ParseError,
     SyntaxKind::{self, EOF, ERROR, TOMBSTONE},
-    TokenSet, TokenSource, T,
+    Token, TokenSet, TokenSource, T,
 };
 
 /// `Parser` struct provides the low-level API for
@@ -87,8 +87,9 @@ impl<'t> Parser<'t> {
         let mut i = 0;
 
         loop {
-            let mut kind = self.token_source.lookahead_nth(i).kind;
-            if let Some((composited, step)) = self.is_composite(kind, i) {
+            let token = self.token_source.lookahead_nth(i);
+            let mut kind = token.kind;
+            if let Some((composited, step)) = self.is_composite(token, i) {
                 kind = composited;
                 i += step;
             } else {
@@ -250,32 +251,47 @@ impl<'t> Parser<'t> {
     }
 
     /// helper function for check if it is composite.
-    fn is_composite(&self, kind: SyntaxKind, n: usize) -> Option<(SyntaxKind, usize)> {
+    fn is_composite(&self, first: Token, n: usize) -> Option<(SyntaxKind, usize)> {
         // We assume the dollars will not occuried between
         // mult-byte tokens
 
-        let first = self.token_source.lookahead_nth(n);
+        let jn1 = first.is_jointed_to_next;
+        if !jn1 && first.kind != T![-] {
+            return None;
+        }
+
         let second = self.token_source.lookahead_nth(n + 1);
+        if first.kind == T![-] && second.kind == T![>] {
+            return Some((T![->], 2));
+        }
+        if !jn1 {
+            return None;
+        }
+
+        match (first.kind, second.kind) {
+            (T![:], T![:]) => return Some((T![::], 2)),
+            (T![=], T![=]) => return Some((T![==], 2)),
+            (T![=], T![>]) => return Some((T![=>], 2)),
+            (T![!], T![=]) => return Some((T![!=], 2)),
+            _ => {}
+        }
+
+        if first.kind != T![.] || second.kind != T![.] {
+            return None;
+        }
+
         let third = self.token_source.lookahead_nth(n + 2);
 
-        let jn1 = first.is_jointed_to_next;
-        let la2 = second.kind;
         let jn2 = second.is_jointed_to_next;
         let la3 = third.kind;
 
-        match kind {
-            T![.] if jn1 && la2 == T![.] && jn2 && la3 == T![.] => Some((T![...], 3)),
-            T![.] if jn1 && la2 == T![.] && la3 == T![=] => Some((T![..=], 3)),
-            T![.] if jn1 && la2 == T![.] => Some((T![..], 2)),
-
-            T![:] if jn1 && la2 == T![:] => Some((T![::], 2)),
-            T![=] if jn1 && la2 == T![=] => Some((T![==], 2)),
-            T![=] if jn1 && la2 == T![>] => Some((T![=>], 2)),
-
-            T![!] if jn1 && la2 == T![=] => Some((T![!=], 2)),
-            T![-] if la2 == T![>] => Some((T![->], 2)),
-            _ => None,
+        if jn2 && la3 == T![.] {
+            return Some((T![...], 3));
+        }
+        if la3 == T![=] {
+            return Some((T![..=], 3));
         }
+        return Some((T![..], 2));
     }
 
     fn eat_dollars(&mut self) {
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index 3545d23c9..4fd6c75ef 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -7,7 +7,6 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 log = "0.4.5"
 rustc-hash = "1.0"
-relative-path = "0.4.0"
 
 cargo_metadata = "0.8.0"
 
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 2b06e9e37..712d8818f 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -167,7 +167,7 @@ impl CargoWorkspace {
         Ok(CargoWorkspace { packages, targets, workspace_root: meta.workspace_root })
     }
 
-    pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + 'a {
+    pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + ExactSizeIterator + 'a {
         self.packages.iter().map(|(id, _pkg)| id)
     }
 
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 08e5c1c32..55b94b911 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -9,14 +9,10 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use rustc_hash::FxHashMap;
-
 use ra_db::{CrateGraph, Edition, FileId};
-
+use rustc_hash::FxHashMap;
 use serde_json::from_reader;
 
-use relative_path::RelativePath;
-
 pub use crate::{
     cargo_workspace::{CargoWorkspace, Package, Target, TargetKind},
     json_project::JsonProject,
@@ -34,20 +30,20 @@ pub enum ProjectWorkspace {
     Json { project: JsonProject },
 }
 
-/// `ProjectRoot` describes a workspace root folder.
+/// `PackageRoot` describes a package root folder.
 /// Which may be an external dependency, or a member of
 /// the current workspace.
 #[derive(Clone)]
-pub struct ProjectRoot {
+pub struct PackageRoot {
     /// Path to the root folder
     path: PathBuf,
     /// Is a member of the current workspace
     is_member: bool,
 }
 
-impl ProjectRoot {
-    pub fn new(path: PathBuf, is_member: bool) -> ProjectRoot {
-        ProjectRoot { path, is_member }
+impl PackageRoot {
+    pub fn new(path: PathBuf, is_member: bool) -> PackageRoot {
+        PackageRoot { path, is_member }
     }
 
     pub fn path(&self) -> &PathBuf {
@@ -57,28 +53,6 @@ impl ProjectRoot {
     pub fn is_member(&self) -> bool {
         self.is_member
     }
-
-    pub fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        const COMMON_IGNORED_DIRS: &[&str] = &["node_modules", "target", ".git"];
-        const EXTERNAL_IGNORED_DIRS: &[&str] = &["examples", "tests", "benches"];
-
-        let is_ignored = if self.is_member {
-            dir_path.components().any(|c| COMMON_IGNORED_DIRS.contains(&c.as_str()))
-        } else {
-            dir_path.components().any(|c| {
-                let path = c.as_str();
-                COMMON_IGNORED_DIRS.contains(&path) || EXTERNAL_IGNORED_DIRS.contains(&path)
-            })
-        };
-
-        let hidden = dir_path.components().any(|c| c.as_str().starts_with('.'));
-
-        !is_ignored && !hidden
-    }
-
-    pub fn include_file(&self, file_path: &RelativePath) -> bool {
-        file_path.extension() == Some("rs")
-    }
 }
 
 impl ProjectWorkspace {
@@ -99,38 +73,39 @@ impl ProjectWorkspace {
         }
     }
 
-    /// Returns the roots for the current ProjectWorkspace
+    /// Returns the roots for the current `ProjectWorkspace`
     /// The return type contains the path and whether or not
     /// the root is a member of the current workspace
-    pub fn to_roots(&self) -> Vec<ProjectRoot> {
+    pub fn to_roots(&self) -> Vec<PackageRoot> {
         match self {
             ProjectWorkspace::Json { project } => {
                 let mut roots = Vec::with_capacity(project.roots.len());
                 for root in &project.roots {
-                    roots.push(ProjectRoot::new(root.path.clone(), true));
+                    roots.push(PackageRoot::new(root.path.clone(), true));
                 }
                 roots
             }
             ProjectWorkspace::Cargo { cargo, sysroot } => {
-                let mut roots =
-                    Vec::with_capacity(cargo.packages().count() + sysroot.crates().count());
+                let mut roots = Vec::with_capacity(cargo.packages().len() + sysroot.crates().len());
                 for pkg in cargo.packages() {
                     let root = pkg.root(&cargo).to_path_buf();
                     let member = pkg.is_member(&cargo);
-                    roots.push(ProjectRoot::new(root, member));
+                    roots.push(PackageRoot::new(root, member));
                 }
                 for krate in sysroot.crates() {
-                    roots.push(ProjectRoot::new(krate.root_dir(&sysroot).to_path_buf(), false))
+                    roots.push(PackageRoot::new(krate.root_dir(&sysroot).to_path_buf(), false))
                 }
                 roots
             }
         }
     }
 
-    pub fn count(&self) -> usize {
+    pub fn n_packages(&self) -> usize {
         match self {
             ProjectWorkspace::Json { project } => project.crates.len(),
-            ProjectWorkspace::Cargo { cargo, .. } => cargo.packages().count(),
+            ProjectWorkspace::Cargo { cargo, sysroot } => {
+                cargo.packages().len() + sysroot.crates().len()
+            }
         }
     }
 
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index 4f6e880dd..3f34d51cc 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -28,7 +28,7 @@ impl Sysroot {
         self.by_name("std")
     }
 
-    pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + 'a {
+    pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a {
         self.crates.iter().map(|(id, _data)| id)
     }
 
diff --git a/crates/ra_vfs_glob/Cargo.toml b/crates/ra_vfs_glob/Cargo.toml
new file mode 100644
index 000000000..0390d7da1
--- /dev/null
+++ b/crates/ra_vfs_glob/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+edition = "2018"
+name = "ra_vfs_glob"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+
+[dependencies]
+ra_vfs = "0.2.0"
+globset = "0.4.4"
diff --git a/crates/ra_vfs_glob/src/lib.rs b/crates/ra_vfs_glob/src/lib.rs
new file mode 100644
index 000000000..12401d75a
--- /dev/null
+++ b/crates/ra_vfs_glob/src/lib.rs
@@ -0,0 +1,94 @@
+//! `ra_vfs_glob` crate implements exclusion rules for vfs.
+//!
+//! By default, we include only `.rs` files, and skip some know offenders like
+//! `/target` or `/node_modules` altogether.
+//!
+//! It's also possible to add custom exclusion globs.
+
+use globset::{GlobSet, GlobSetBuilder};
+use ra_vfs::{Filter, RelativePath};
+
+pub use globset::{Glob, GlobBuilder};
+
+const ALWAYS_IGNORED: &[&str] = &["target/**", "**/node_modules/**", "**/.git/**"];
+const IGNORED_FOR_NON_MEMBERS: &[&str] = &["examples/**", "tests/**", "benches/**"];
+
+pub struct RustPackageFilterBuilder {
+    is_member: bool,
+    exclude: GlobSetBuilder,
+}
+
+impl Default for RustPackageFilterBuilder {
+    fn default() -> RustPackageFilterBuilder {
+        RustPackageFilterBuilder { is_member: false, exclude: GlobSetBuilder::new() }
+    }
+}
+
+impl RustPackageFilterBuilder {
+    pub fn set_member(mut self, is_member: bool) -> RustPackageFilterBuilder {
+        self.is_member = is_member;
+        self
+    }
+    pub fn exclude(mut self, glob: Glob) -> RustPackageFilterBuilder {
+        self.exclude.add(glob);
+        self
+    }
+    pub fn into_vfs_filter(self) -> Box<dyn Filter> {
+        let RustPackageFilterBuilder { is_member, mut exclude } = self;
+        for &glob in ALWAYS_IGNORED {
+            exclude.add(Glob::new(glob).unwrap());
+        }
+        if !is_member {
+            for &glob in IGNORED_FOR_NON_MEMBERS {
+                exclude.add(Glob::new(glob).unwrap());
+            }
+        }
+        Box::new(RustPackageFilter { exclude: exclude.build().unwrap() })
+    }
+}
+
+struct RustPackageFilter {
+    exclude: GlobSet,
+}
+
+impl Filter for RustPackageFilter {
+    fn include_dir(&self, dir_path: &RelativePath) -> bool {
+        !self.exclude.is_match(dir_path.as_str())
+    }
+
+    fn include_file(&self, file_path: &RelativePath) -> bool {
+        file_path.extension() == Some("rs")
+    }
+}
+
+#[test]
+fn test_globs() {
+    let filter = RustPackageFilterBuilder::default().set_member(true).into_vfs_filter();
+
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+    assert!(filter.include_dir(RelativePath::new("tests")));
+    assert!(filter.include_dir(RelativePath::new("benches")));
+
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+
+    let filter = RustPackageFilterBuilder::default().set_member(false).into_vfs_filter();
+
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+    assert!(!filter.include_dir(RelativePath::new("tests")));
+    assert!(!filter.include_dir(RelativePath::new("benches")));
+
+    let filter = RustPackageFilterBuilder::default()
+        .set_member(true)
+        .exclude(Glob::new("src/llvm-project/**").unwrap())
+        .into_vfs_filter();
+
+    assert!(!filter.include_dir(RelativePath::new("src/llvm-project/clang")));
+}