19 files changed, 161 insertions, 79 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 752edddd6..e6c7da51f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1376,9 +1376,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.1.56"
+version = "0.1.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 
 [[package]]
 name = "regex"
@@ -1798,9 +1798,9 @@ checksum = "53953d2d3a5ad81d9f844a32f14ebb121f50b650cd59d0ee2a07cf13c617efed"
 
 [[package]]
 name = "tracing"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41f40ed0e162c911ac6fcb53ecdc8134c46905fdbbae8c50add462a538b495f"
+checksum = "c2e2a2de6b0d5cbb13fc21193a2296888eaab62b6044479aafb3c54c01c29fcd"
 dependencies = [
  "cfg-if",
  "tracing-attributes",
@@ -1820,9 +1820,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aa83a9a47081cd522c09c81b31aec2c9273424976f922ad61c053b58350b715"
+checksum = "94ae75f0d28ae10786f3b1895c55fe72e79928fd5ccdebb5438c75e93fec178f"
 dependencies = [
  "lazy_static",
 ]
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 0d877e44e..4a16ac566 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -568,6 +568,7 @@ fn find_root(node: &SyntaxNode) -> SyntaxNode {
     node.ancestors().last().unwrap()
 }
 
+#[derive(Debug)]
 pub struct SemanticsScope<'a> {
     pub db: &'a dyn HirDatabase,
     resolver: Resolver,
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index 9db317509..047299de9 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -195,7 +195,7 @@ fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>,
 
 fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
     let mut result = FxHashSet::default();
-    ctx.scope().process_all_names(&mut |name, scope_def| {
+    ctx.scope.process_all_names(&mut |name, scope_def| {
         if let hir::ScopeDef::MacroDef(mac) = scope_def {
             if mac.is_derive_macro() {
                 result.insert(name.to_string());
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 3c6c8c81a..532665285 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -29,7 +29,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     for receiver in receiver.autoderef(ctx.db) {
         for (field, ty) in receiver.fields(ctx.db) {
-            if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+            if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                 // Skip private field. FIXME: If the definition location of the
                 // field is editable, we should show the completion
                 continue;
@@ -46,10 +46,10 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     if let Some(krate) = ctx.krate {
         let mut seen_methods = FxHashSet::default();
-        let traits_in_scope = ctx.scope().traits_in_scope();
+        let traits_in_scope = ctx.scope.traits_in_scope();
         receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
             if func.has_self_param(ctx.db)
-                && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
+                && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
                 && seen_methods.insert(func.name(ctx.db))
             {
                 acc.add_function(ctx, func, None);
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
index d6613ed7b..0447f0511 100644
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -5,7 +5,7 @@ use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
     if ctx.is_new_item {
-        ctx.scope().process_all_names(&mut |name, res| {
+        ctx.scope.process_all_names(&mut |name, res| {
             if let hir::ScopeDef::MacroDef(mac) = res {
                 acc.add_macro(ctx, Some(name.to_string()), mac);
             }
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index 13fa7548d..aceb77cb5 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -13,7 +13,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         match &res {
             hir::ScopeDef::ModuleDef(def) => match def {
                 hir::ModuleDef::Adt(hir::Adt::Enum(..))
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index e5553e28f..b08f5b9b4 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -17,21 +17,20 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         return;
     }
 
-    let scope = ctx.scope();
-    let context_module = scope.module();
+    let context_module = ctx.scope.module();
 
-    let res = match scope.resolve_hir_path_qualifier(&path) {
+    let resolution = match ctx.scope.resolve_hir_path_qualifier(&path) {
         Some(res) => res,
         None => return,
     };
 
     // Add associated types on type parameters and `Self`.
-    res.assoc_type_shorthand_candidates(ctx.db, |alias| {
+    resolution.assoc_type_shorthand_candidates(ctx.db, |alias| {
         acc.add_type_alias(ctx, alias);
         None::<()>
     });
 
-    match res {
+    match resolution {
         PathResolution::Def(hir::ModuleDef::Module(module)) => {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
@@ -68,7 +67,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
             let krate = ctx.krate;
             if let Some(krate) = krate {
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                         return None;
@@ -113,13 +112,13 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         }
         PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
             if let Some(krate) = ctx.krate {
-                let ty = match res {
+                let ty = match resolution {
                     PathResolution::TypeParam(param) => param.ty(ctx.db),
                     PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db),
                     _ => return,
                 };
 
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 let mut seen = FxHashSet::default();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index 18f4488b7..bd9551f35 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -25,7 +25,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
 
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         if ctx.use_item_syntax.is_some() {
             if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                 if name_ref.syntax().text() == name.to_string().as_str() {
@@ -42,7 +42,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
     if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
         let variants = enum_data.variants(ctx.db);
 
-        let module = if let Some(module) = ctx.scope().module() {
+        let module = if let Some(module) = ctx.scope.module() {
             // Compute path from the completion site if available.
             module
         } else {
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 02811a91e..3d93f7067 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -24,6 +24,7 @@ use test_utils::mark;
 #[derive(Debug)]
 pub(crate) struct CompletionContext<'a> {
     pub(super) sema: Semantics<'a, RootDatabase>,
+    pub(super) scope: SemanticsScope<'a>,
     pub(super) db: &'a RootDatabase,
     pub(super) config: &'a CompletionConfig,
     pub(super) offset: TextSize,
@@ -106,8 +107,10 @@ impl<'a> CompletionContext<'a> {
         let original_token =
             original_file.syntax().token_at_offset(position.offset).left_biased()?;
         let token = sema.descend_into_macros(original_token.clone());
+        let scope = sema.scope_at_offset(&token.parent(), position.offset);
         let mut ctx = CompletionContext {
             sema,
+            scope,
             db,
             config,
             original_token,
@@ -207,10 +210,6 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
-    pub(crate) fn scope(&self) -> SemanticsScope<'_> {
-        self.sema.scope_at_offset(&self.token.parent(), self.offset)
-    }
-
     fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
         let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
         let syntax_element = NodeOrToken::Token(fake_ident_token.clone());
diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml
index c33b5121a..eabfcebb0 100644
--- a/crates/ra_prof/Cargo.toml
+++ b/crates/ra_prof/Cargo.toml
@@ -20,3 +20,8 @@ jemalloc-ctl = { version = "0.3.3", optional = true }
 [features]
 jemalloc = [ "jemallocator", "jemalloc-ctl" ]
 cpu_profiler = []
+
+# Uncomment to enable for the whole crate graph
+# default = [ "backtrace" ]
+# default = [ "jemalloc" ]
+# default = [ "cpu_profiler" ]
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 89df7f04b..7163a8424 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -43,6 +43,7 @@ pub struct Scope {
 }
 
 impl Scope {
+    #[must_use]
     pub fn enter() -> Scope {
         let prev = IN_SCOPE.with(|slot| std::mem::replace(&mut *slot.borrow_mut(), true));
         Scope { prev }
@@ -65,7 +66,8 @@ impl Drop for Scope {
 /// 2. Build with `cpu_profiler` feature.
 /// 3. Tun the code, the *raw* output would be in the `./out.profile` file.
 /// 4. Install pprof for visualization (https://github.com/google/pprof).
-/// 5. Use something like `pprof -svg target/release/rust-analyzer ./out.profile` to see the results.
+/// 5. Bump sampling frequency to once per ms: `export CPUPROFILE_FREQUENCY=1000`
+/// 6. Use something like `pprof -svg target/release/rust-analyzer ./out.profile` to see the results.
 ///
 /// For example, here's how I run profiling on NixOS:
 ///
@@ -73,11 +75,16 @@ impl Drop for Scope {
 /// $ nix-shell -p gperftools --run \
 ///     'cargo run --release -p rust-analyzer -- parse < ~/projects/rustbench/parser.rs > /dev/null'
 /// ```
+///
+/// See this diff for how to profile completions:
+///
+/// https://github.com/rust-analyzer/rust-analyzer/pull/5306
 #[derive(Debug)]
 pub struct CpuProfiler {
     _private: (),
 }
 
+#[must_use]
 pub fn cpu_profiler() -> CpuProfiler {
     #[cfg(feature = "cpu_profiler")]
     {
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 6d1154056..4182ca156 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -155,7 +155,7 @@ impl CargoWorkspace {
         if let Some(target) = cargo_features.target.as_ref() {
             meta.other_options(vec![String::from("--filter-platform"), target.clone()]);
         }
-        let meta = meta.exec().with_context(|| {
+        let mut meta = meta.exec().with_context(|| {
             format!("Failed to run `cargo metadata --manifest-path {}`", cargo_toml.display())
         })?;
 
@@ -175,6 +175,7 @@ impl CargoWorkspace {
 
         let ws_members = &meta.workspace_members;
 
+        meta.packages.sort_by(|a, b| a.id.cmp(&b.id));
         for meta_pkg in meta.packages {
             let cargo_metadata::Package { id, edition, name, manifest_path, version, .. } =
                 meta_pkg;
@@ -210,7 +211,7 @@ impl CargoWorkspace {
             }
         }
         let resolve = meta.resolve.expect("metadata executed with deps");
-        for node in resolve.nodes {
+        for mut node in resolve.nodes {
             let source = match pkg_by_id.get(&node.id) {
                 Some(&src) => src,
                 // FIXME: replace this and a similar branch below with `.unwrap`, once
@@ -221,6 +222,7 @@ impl CargoWorkspace {
                     continue;
                 }
             };
+            node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg));
             for dep_node in node.deps {
                 let pkg = match pkg_by_id.get(&dep_node.pkg) {
                     Some(&pkg) => pkg,
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index c8d34e15a..9a9a6547a 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -26,6 +26,7 @@ use crate::{
     to_proto::url_from_abs_path,
     Result,
 };
+use ra_prof::profile;
 
 #[derive(Eq, PartialEq, Copy, Clone)]
 pub(crate) enum Status {
@@ -122,6 +123,10 @@ impl GlobalState {
     }
 
     pub(crate) fn process_changes(&mut self) -> bool {
+        let _p = profile("GlobalState::process_changes");
+        let mut fs_changes = Vec::new();
+        let mut has_fs_changes = false;
+
         let change = {
             let mut change = AnalysisChange::new();
             let (vfs, line_endings_map) = &mut *self.vfs.write();
@@ -130,13 +135,14 @@ impl GlobalState {
                 return false;
             }
 
-            let fs_op = changed_files.iter().any(|it| it.is_created_or_deleted());
-            if fs_op {
-                let roots = self.source_root_config.partition(&vfs);
-                change.set_roots(roots)
-            }
-
             for file in changed_files {
+                if file.is_created_or_deleted() {
+                    if let Some(path) = vfs.file_path(file.file_id).as_path() {
+                        fs_changes.push((path.to_path_buf(), file.change_kind));
+                        has_fs_changes = true;
+                    }
+                }
+
                 let text = if file.exists() {
                     let bytes = vfs.file_contents(file.file_id).to_vec();
                     match String::from_utf8(bytes).ok() {
@@ -152,10 +158,15 @@ impl GlobalState {
                 };
                 change.change_file(file.file_id, text);
             }
+            if has_fs_changes {
+                let roots = self.source_root_config.partition(&vfs);
+                change.set_roots(roots);
+            }
             change
         };
 
         self.analysis_host.apply_change(change);
+        self.maybe_refresh(&fs_changes);
         true
     }
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 96e2399ce..702f25a19 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -22,6 +22,7 @@ use crate::{
     Result,
 };
 use ra_project_model::ProjectWorkspace;
+use vfs::ChangeKind;
 
 pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
     log::info!("initial config: {:#?}", config);
@@ -197,39 +198,49 @@ impl GlobalState {
                 }
                 self.analysis_host.maybe_collect_garbage();
             }
-            Event::Vfs(task) => match task {
-                vfs::loader::Message::Loaded { files } => {
-                    let vfs = &mut self.vfs.write().0;
-                    for (path, contents) in files {
-                        let path = VfsPath::from(path);
-                        if !self.mem_docs.contains(&path) {
-                            vfs.set_file_contents(path, contents)
+            Event::Vfs(mut task) => {
+                let _p = profile("GlobalState::handle_event/vfs");
+                loop {
+                    match task {
+                        vfs::loader::Message::Loaded { files } => {
+                            let vfs = &mut self.vfs.write().0;
+                            for (path, contents) in files {
+                                let path = VfsPath::from(path);
+                                if !self.mem_docs.contains(&path) {
+                                    vfs.set_file_contents(path, contents)
+                                }
+                            }
+                        }
+                        vfs::loader::Message::Progress { n_total, n_done } => {
+                            if n_total == 0 {
+                                self.transition(Status::Invalid);
+                            } else {
+                                let state = if n_done == 0 {
+                                    self.transition(Status::Loading);
+                                    Progress::Begin
+                                } else if n_done < n_total {
+                                    Progress::Report
+                                } else {
+                                    assert_eq!(n_done, n_total);
+                                    self.transition(Status::Ready);
+                                    Progress::End
+                                };
+                                self.report_progress(
+                                    "roots scanned",
+                                    state,
+                                    Some(format!("{}/{}", n_done, n_total)),
+                                    Some(Progress::percentage(n_done, n_total)),
+                                )
+                            }
                         }
                     }
-                }
-                vfs::loader::Message::Progress { n_total, n_done } => {
-                    if n_total == 0 {
-                        self.transition(Status::Invalid);
-                    } else {
-                        let state = if n_done == 0 {
-                            self.transition(Status::Loading);
-                            Progress::Begin
-                        } else if n_done < n_total {
-                            Progress::Report
-                        } else {
-                            assert_eq!(n_done, n_total);
-                            self.transition(Status::Ready);
-                            Progress::End
-                        };
-                        self.report_progress(
-                            "roots scanned",
-                            state,
-                            Some(format!("{}/{}", n_done, n_total)),
-                            Some(Progress::percentage(n_done, n_total)),
-                        )
+                    // Coalesce many VFS event into a single loop turn
+                    task = match self.loader.receiver.try_recv() {
+                        Ok(task) => task,
+                        Err(_) => break,
                     }
                 }
-            },
+            }
             Event::Flycheck(task) => match task {
                 flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
                     let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
@@ -428,7 +439,9 @@ impl GlobalState {
                 if let Some(flycheck) = &this.flycheck {
                     flycheck.handle.update();
                 }
-                this.maybe_refresh(params.text_document.uri.as_str());
+                if let Ok(abs_path) = from_proto::abs_path(&params.text_document.uri) {
+                    this.maybe_refresh(&[(abs_path, ChangeKind::Modify)]);
+                }
                 Ok(())
             })?
             .on::<lsp_types::notification::DidChangeConfiguration>(|this, _params| {
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 0a201fceb..ab1b18ea9 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -6,7 +6,7 @@ use flycheck::FlycheckHandle;
 use ra_db::{CrateGraph, SourceRoot, VfsPath};
 use ra_ide::AnalysisChange;
 use ra_project_model::{PackageRoot, ProcMacroClient, ProjectWorkspace};
-use vfs::{file_set::FileSetConfig, AbsPath};
+use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};
 
 use crate::{
     config::{Config, FilesWatcher, LinkedProject},
@@ -14,9 +14,11 @@ use crate::{
     lsp_ext,
     main_loop::Task,
 };
+use ra_prof::profile;
 
 impl GlobalState {
     pub(crate) fn update_configuration(&mut self, config: Config) {
+        let _p = profile("GlobalState::update_configuration");
         let old_config = mem::replace(&mut self.config, config);
         if self.config.lru_capacity != old_config.lru_capacity {
             self.analysis_host.update_lru_capacity(old_config.lru_capacity);
@@ -27,8 +29,8 @@ impl GlobalState {
             self.reload_flycheck();
         }
     }
-    pub(crate) fn maybe_refresh(&mut self, saved_doc_url: &str) {
-        if !(saved_doc_url.ends_with("Cargo.toml") || saved_doc_url.ends_with("Cargo.lock")) {
+    pub(crate) fn maybe_refresh(&mut self, changes: &[(AbsPathBuf, ChangeKind)]) {
+        if !changes.iter().any(|(path, kind)| is_interesting(path, *kind)) {
             return;
         }
         match self.status {
@@ -40,6 +42,41 @@ impl GlobalState {
         } else {
             self.transition(Status::NeedsReload);
         }
+
+        fn is_interesting(path: &AbsPath, change_kind: ChangeKind) -> bool {
+            const IMPLICIT_TARGET_FILES: &[&str] = &["build.rs", "src/main.rs", "src/lib.rs"];
+            const IMPLICIT_TARGET_DIRS: &[&str] = &["src/bin", "examples", "tests", "benches"];
+
+            if path.ends_with("Cargo.toml") || path.ends_with("Cargo.lock") {
+                return true;
+            }
+            if change_kind == ChangeKind::Modify {
+                return false;
+            }
+            if path.extension().unwrap_or_default() != "rs" {
+                return false;
+            }
+            if IMPLICIT_TARGET_FILES.iter().any(|it| path.ends_with(it)) {
+                return true;
+            }
+            let parent = match path.parent() {
+                Some(it) => it,
+                None => return false,
+            };
+            if IMPLICIT_TARGET_DIRS.iter().any(|it| parent.ends_with(it)) {
+                return true;
+            }
+            if path.ends_with("main.rs") {
+                let grand_parent = match parent.parent() {
+                    Some(it) => it,
+                    None => return false,
+                };
+                if IMPLICIT_TARGET_DIRS.iter().any(|it| grand_parent.ends_with(it)) {
+                    return true;
+                }
+            }
+            false
+        }
     }
     pub(crate) fn transition(&mut self, new_status: Status) {
         self.status = new_status;
@@ -79,6 +116,7 @@ impl GlobalState {
         });
     }
     pub(crate) fn switch_workspaces(&mut self, workspaces: Vec<anyhow::Result<ProjectWorkspace>>) {
+        let _p = profile("GlobalState::switch_workspaces");
         log::info!("reloading projects: {:?}", self.config.linked_projects);
 
         let mut has_errors = false;
@@ -88,10 +126,12 @@ impl GlobalState {
                 res.map_err(|err| {
                     has_errors = true;
                     log::error!("failed to load workspace: {:#}", err);
-                    self.show_message(
-                        lsp_types::MessageType::Error,
-                        format!("rust-analyzer failed to load workspace: {:#}", err),
-                    );
+                    if self.workspaces.is_empty() {
+                        self.show_message(
+                            lsp_types::MessageType::Error,
+                            format!("rust-analyzer failed to load workspace: {:#}", err),
+                        );
+                    }
                 })
                 .ok()
             })
@@ -144,6 +184,7 @@ impl GlobalState {
                 }
             },
         };
+
         let watch = match self.config.files.watcher {
             FilesWatcher::Client => vec![],
             FilesWatcher::Notify => project_folders.watch,
@@ -267,6 +308,7 @@ pub(crate) struct SourceRootConfig {
 
 impl SourceRootConfig {
     pub(crate) fn partition(&self, vfs: &vfs::Vfs) -> Vec<SourceRoot> {
+        let _p = profile("SourceRootConfig::partition");
         self.fsc
             .partition(vfs)
             .into_iter()
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 08ac6f70f..3b605c79d 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -87,6 +87,8 @@ where
         Ok(())
     }
 }
+
+#[must_use]
 pub fn timeit(label: &'static str) -> impl Drop {
     struct Guard {
         label: &'static str,
diff --git a/crates/vfs-notify/src/include.rs b/crates/vfs-notify/src/include.rs
index 72f928536..59da3d77a 100644
--- a/crates/vfs-notify/src/include.rs
+++ b/crates/vfs-notify/src/include.rs
@@ -1,5 +1,4 @@
 //! See `Include`.
-
 use std::convert::TryFrom;
 
 use globset::{Glob, GlobSet, GlobSetBuilder};
diff --git a/crates/vfs-notify/src/lib.rs b/crates/vfs-notify/src/lib.rs
index ee5035554..6aaa53f63 100644
--- a/crates/vfs-notify/src/lib.rs
+++ b/crates/vfs-notify/src/lib.rs
@@ -82,11 +82,13 @@ impl NotifyActor {
                 Event::Message(msg) => match msg {
                     Message::Config(config) => {
                         self.watcher = None;
-                        let (watcher_sender, watcher_receiver) = unbounded();
-                        let watcher = log_notify_error(Watcher::new_immediate(move |event| {
-                            watcher_sender.send(event).unwrap()
-                        }));
-                        self.watcher = watcher.map(|it| (it, watcher_receiver));
+                        if !config.watch.is_empty() {
+                            let (watcher_sender, watcher_receiver) = unbounded();
+                            let watcher = log_notify_error(Watcher::new_immediate(move |event| {
+                                watcher_sender.send(event).unwrap()
+                            }));
+                            self.watcher = watcher.map(|it| (it, watcher_receiver));
+                        }
 
                         let n_total = config.load.len();
                         self.send(loader::Message::Progress { n_total, n_done: 0 });
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index 024e58018..3bfecd08f 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -70,7 +70,7 @@ impl ChangedFile {
     }
 }
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum ChangeKind {
     Create,
     Modify,