18 files changed, 155 insertions, 73 deletions
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 = ctx.scope.module();
-    let context_module = 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 {
+            Event::Vfs(mut task) => {
-                vfs::loader::Message::Loaded { files } => {
+                let _p = profile("GlobalState::handle_event/vfs");
-                    let vfs = &mut self.vfs.write().0;
+                loop {
-                    for (path, contents) in files {
+                    match task {
-                        let path = VfsPath::from(path);
+                        vfs::loader::Message::Loaded { files } => {
-                        if !self.mem_docs.contains(&path) {
+                            let vfs = &mut self.vfs.write().0;
-                            vfs.set_file_contents(path, contents)
+                            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)),
+                                )
+                            }
                        }
                    }
-                }
+                    // Coalesce many VFS event into a single loop turn
-                vfs::loader::Message::Progress { n_total, n_done } => {
+                    task = match self.loader.receiver.try_recv() {
-                    if n_total == 0 {
+                        Ok(task) => task,
-                        self.transition(Status::Invalid);
+                        Err(_) => break,
-                    } 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)),
-                        )
                    }
                }
-            },
+            }
            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) {
+    pub(crate) fn maybe_refresh(&mut self, changes: &[(AbsPathBuf, ChangeKind)]) {
-        if !(saved_doc_url.ends_with("Cargo.toml") || saved_doc_url.ends_with("Cargo.lock")) {
+        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(
+                    if self.workspaces.is_empty() {
-                        lsp_types::MessageType::Error,
+                        self.show_message(
-                        format!("rust-analyzer failed to load workspace: {:#}", err),
+                            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();
+                        if !config.watch.is_empty() {
-                        let watcher = log_notify_error(Watcher::new_immediate(move |event| {
+                            let (watcher_sender, watcher_receiver) = unbounded();
-                            watcher_sender.send(event).unwrap()
+                            let watcher = log_notify_error(Watcher::new_immediate(move |event| {
-                        }));
+                                watcher_sender.send(event).unwrap()
-                        self.watcher = watcher.map(|it| (it, watcher_receiver));
+                            }));
+                            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,