12 files changed, 483 insertions, 527 deletions

diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index c1124b9e2..8ac20210a 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -1,6 +1,7 @@
 use base_db::FileId;
 use hir::{EnumVariant, Module, ModuleDef, Name};
 use ide_db::{defs::Definition, search::Reference, RootDatabase};
+use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use syntax::{
     algo::find_node_at_offset,
@@ -203,13 +204,11 @@ fn list_with_visibility(list: &str) -> String {
             mod_part.insert_str(index, "pub ");
             mod_part
         })
-        .collect::<Vec<String>>()
         .join(", ")
 }
 
 #[cfg(test)]
 mod tests {
-
     use crate::{
         tests::{check_assist, check_assist_not_applicable},
         utils::FamousDefs,
diff --git a/crates/assists/src/handlers/inline_local_variable.rs b/crates/assists/src/handlers/inline_local_variable.rs
index 164bbce86..587eb5feb 100644
--- a/crates/assists/src/handlers/inline_local_variable.rs
+++ b/crates/assists/src/handlers/inline_local_variable.rs
@@ -1,4 +1,4 @@
-use ide_db::defs::Definition;
+use ide_db::{defs::Definition, search::ReferenceKind};
 use syntax::{
     ast::{self, AstNode, AstToken},
     TextRange,
@@ -119,7 +119,13 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
             for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
                 let replacement =
                     if should_wrap { init_in_paren.clone() } else { init_str.clone() };
-                builder.replace(desc.file_range.range, replacement)
+                match desc.kind {
+                    ReferenceKind::FieldShorthandForLocal => {
+                        mark::hit!(inline_field_shorthand);
+                        builder.insert(desc.file_range.range.end(), format!(": {}", replacement))
+                    }
+                    _ => builder.replace(desc.file_range.range, replacement),
+                }
             }
         },
     )
@@ -667,6 +673,27 @@ fn foo() {
     }
 
     #[test]
+    fn inline_field_shorthand() {
+        mark::check!(inline_field_shorthand);
+        check_assist(
+            inline_local_variable,
+            r"
+struct S { foo: i32}
+fn main() {
+    let <|>foo = 92;
+    S { foo }
+}
+",
+            r"
+struct S { foo: i32}
+fn main() {
+    S { foo: 92 }
+}
+",
+        );
+    }
+
+    #[test]
     fn test_not_applicable_if_variable_unused() {
         mark::check!(test_not_applicable_if_variable_unused);
         check_assist_not_applicable(
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index 2d65fc076..2d91939ce 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -39,11 +39,18 @@ pub enum ProjectWorkspace {
 impl fmt::Debug for ProjectWorkspace {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ProjectWorkspace::Cargo { cargo, .. } => {
-                f.debug_struct("Cargo").field("n_packages", &cargo.packages().len()).finish()
-            }
+            ProjectWorkspace::Cargo { cargo, sysroot } => f
+                .debug_struct("Cargo")
+                .field("n_packages", &cargo.packages().len())
+                .field("n_sysroot_crates", &sysroot.crates().len())
+                .finish(),
             ProjectWorkspace::Json { project } => {
-                f.debug_struct("Json").field("n_crates", &project.crates.len()).finish()
+                let mut debug_struct = f.debug_struct("Json");
+                debug_struct.field("n_crates", &project.n_crates());
+                if let Some(sysroot) = &project.sysroot {
+                    debug_struct.field("n_sysroot_crates", &sysroot.crates().len());
+                }
+                debug_struct.finish()
             }
         }
     }
@@ -202,15 +209,21 @@ impl ProjectWorkspace {
     pub fn to_roots(&self) -> Vec<PackageRoot> {
         match self {
             ProjectWorkspace::Json { project } => project
-                .crates
-                .iter()
-                .map(|krate| PackageRoot {
+                .crates()
+                .map(|(_, krate)| PackageRoot {
                     is_member: krate.is_workspace_member,
                     include: krate.include.clone(),
                     exclude: krate.exclude.clone(),
                 })
                 .collect::<FxHashSet<_>>()
                 .into_iter()
+                .chain(project.sysroot.as_ref().into_iter().flat_map(|sysroot| {
+                    sysroot.crates().map(move |krate| PackageRoot {
+                        is_member: false,
+                        include: vec![sysroot[krate].root_dir().to_path_buf()],
+                        exclude: Vec::new(),
+                    })
+                }))
                 .collect::<Vec<_>>(),
             ProjectWorkspace::Cargo { cargo, sysroot } => cargo
                 .packages()
@@ -243,9 +256,8 @@ impl ProjectWorkspace {
     pub fn proc_macro_dylib_paths(&self) -> Vec<AbsPathBuf> {
         match self {
             ProjectWorkspace::Json { project } => project
-                .crates
-                .iter()
-                .filter_map(|krate| krate.proc_macro_dylib_path.as_ref())
+                .crates()
+                .filter_map(|(_, krate)| krate.proc_macro_dylib_path.as_ref())
                 .cloned()
                 .collect(),
             ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => cargo
@@ -258,7 +270,7 @@ impl ProjectWorkspace {
 
     pub fn n_packages(&self) -> usize {
         match self {
-            ProjectWorkspace::Json { project, .. } => project.crates.len(),
+            ProjectWorkspace::Json { project, .. } => project.n_crates(),
             ProjectWorkspace::Cargo { cargo, sysroot } => {
                 cargo.packages().len() + sysroot.crates().len()
             }
@@ -274,12 +286,15 @@ impl ProjectWorkspace {
         let mut crate_graph = CrateGraph::default();
         match self {
             ProjectWorkspace::Json { project } => {
+                let sysroot_dps = project
+                    .sysroot
+                    .as_ref()
+                    .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load));
+
                 let mut cfg_cache: FxHashMap<Option<&str>, Vec<CfgFlag>> = FxHashMap::default();
                 let crates: FxHashMap<_, _> = project
-                    .crates
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(seq_index, krate)| {
+                    .crates()
+                    .filter_map(|(crate_id, krate)| {
                         let file_path = &krate.root_module;
                         let file_id = load(&file_path)?;
 
@@ -297,9 +312,8 @@ impl ProjectWorkspace {
                         let mut cfg_options = CfgOptions::default();
                         cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned());
 
-                        // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
                         Some((
-                            CrateId(seq_index as u32),
+                            crate_id,
                             crate_graph.add_crate_root(
                                 file_id,
                                 krate.edition,
@@ -313,67 +327,33 @@ impl ProjectWorkspace {
                     })
                     .collect();
 
-                for (id, krate) in project.crates.iter().enumerate() {
-                    for dep in &krate.deps {
-                        let from_crate_id = CrateId(id as u32);
-                        let to_crate_id = dep.crate_id;
-                        if let (Some(&from), Some(&to)) =
-                            (crates.get(&from_crate_id), crates.get(&to_crate_id))
-                        {
-                            if crate_graph.add_dep(from, dep.name.clone(), to).is_err() {
-                                log::error!(
-                                    "cyclic dependency {:?} -> {:?}",
-                                    from_crate_id,
-                                    to_crate_id
-                                );
+                for (from, krate) in project.crates() {
+                    if let Some(&from) = crates.get(&from) {
+                        if let Some((public_deps, _proc_macro)) = &sysroot_dps {
+                            for (name, to) in public_deps.iter() {
+                                if let Err(_) = crate_graph.add_dep(from, name.clone(), *to) {
+                                    log::error!("cyclic dependency on {} for {:?}", name, from)
+                                }
                             }
                         }
-                    }
-                }
-            }
-            ProjectWorkspace::Cargo { cargo, sysroot } => {
-                let mut cfg_options = CfgOptions::default();
-                cfg_options.extend(get_rustc_cfg_options(target));
-
-                let sysroot_crates: FxHashMap<_, _> = sysroot
-                    .crates()
-                    .filter_map(|krate| {
-                        let file_id = load(&sysroot[krate].root)?;
-
-                        let env = Env::default();
-                        let proc_macro = vec![];
-                        let name = sysroot[krate].name.clone();
-                        let crate_id = crate_graph.add_crate_root(
-                            file_id,
-                            Edition::Edition2018,
-                            Some(name),
-                            cfg_options.clone(),
-                            env,
-                            proc_macro,
-                        );
-                        Some((krate, crate_id))
-                    })
-                    .collect();
 
-                for from in sysroot.crates() {
-                    for &to in sysroot[from].deps.iter() {
-                        let name = &sysroot[to].name;
-                        if let (Some(&from), Some(&to)) =
-                            (sysroot_crates.get(&from), sysroot_crates.get(&to))
-                        {
-                            if crate_graph.add_dep(from, CrateName::new(name).unwrap(), to).is_err()
-                            {
-                                log::error!("cyclic dependency between sysroot crates")
+                        for dep in &krate.deps {
+                            let to_crate_id = dep.crate_id;
+                            if let Some(&to) = crates.get(&to_crate_id) {
+                                if let Err(_) = crate_graph.add_dep(from, dep.name.clone(), to) {
+                                    log::error!("cyclic dependency {:?} -> {:?}", from, to);
+                                }
                             }
                         }
                     }
                 }
+            }
+            ProjectWorkspace::Cargo { cargo, sysroot } => {
+                let (public_deps, libproc_macro) =
+                    sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load);
 
-                let libcore = sysroot.core().and_then(|it| sysroot_crates.get(&it).copied());
-                let liballoc = sysroot.alloc().and_then(|it| sysroot_crates.get(&it).copied());
-                let libstd = sysroot.std().and_then(|it| sysroot_crates.get(&it).copied());
-                let libproc_macro =
-                    sysroot.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
+                let mut cfg_options = CfgOptions::default();
+                cfg_options.extend(get_rustc_cfg_options(target));
 
                 let mut pkg_to_lib_crate = FxHashMap::default();
                 let mut pkg_crates = FxHashMap::default();
@@ -424,14 +404,11 @@ impl ProjectWorkspace {
                             }
                             if cargo[tgt].is_proc_macro {
                                 if let Some(proc_macro) = libproc_macro {
-                                    if crate_graph
-                                        .add_dep(
-                                            crate_id,
-                                            CrateName::new("proc_macro").unwrap(),
-                                            proc_macro,
-                                        )
-                                        .is_err()
-                                    {
+                                    if let Err(_) = crate_graph.add_dep(
+                                        crate_id,
+                                        CrateName::new("proc_macro").unwrap(),
+                                        proc_macro,
+                                    ) {
                                         log::error!(
                                             "cyclic dependency on proc_macro for {}",
                                             &cargo[pkg].name
@@ -447,50 +424,24 @@ impl ProjectWorkspace {
                     // Set deps to the core, std and to the lib target of the current package
                     for &from in pkg_crates.get(&pkg).into_iter().flatten() {
                         if let Some((to, name)) = lib_tgt.clone() {
-                            if to != from
-                                && crate_graph
-                                    .add_dep(
-                                        from,
-                                        // For root projects with dashes in their name,
-                                        // cargo metadata does not do any normalization,
-                                        // so we do it ourselves currently
-                                        CrateName::normalize_dashes(&name),
-                                        to,
-                                    )
-                                    .is_err()
-                            {
-                                {
-                                    log::error!(
-                                        "cyclic dependency between targets of {}",
-                                        &cargo[pkg].name
-                                    )
-                                }
-                            }
-                        }
-                        // core is added as a dependency before std in order to
-                        // mimic rustcs dependency order
-                        if let Some(core) = libcore {
-                            if crate_graph
-                                .add_dep(from, CrateName::new("core").unwrap(), core)
-                                .is_err()
-                            {
-                                log::error!("cyclic dependency on core for {}", &cargo[pkg].name)
-                            }
-                        }
-                        if let Some(alloc) = liballoc {
-                            if crate_graph
-                                .add_dep(from, CrateName::new("alloc").unwrap(), alloc)
-                                .is_err()
-                            {
-                                log::error!("cyclic dependency on alloc for {}", &cargo[pkg].name)
+                            // For root projects with dashes in their name,
+                            // cargo metadata does not do any normalization,
+                            // so we do it ourselves currently
+                            let name = CrateName::normalize_dashes(&name);
+                            if to != from && crate_graph.add_dep(from, name, to).is_err() {
+                                log::error!(
+                                    "cyclic dependency between targets of {}",
+                                    &cargo[pkg].name
+                                )
                             }
                         }
-                        if let Some(std) = libstd {
-                            if crate_graph
-                                .add_dep(from, CrateName::new("std").unwrap(), std)
-                                .is_err()
-                            {
-                                log::error!("cyclic dependency on std for {}", &cargo[pkg].name)
+                        for (name, krate) in public_deps.iter() {
+                            if let Err(_) = crate_graph.add_dep(from, name.clone(), *krate) {
+                                log::error!(
+                                    "cyclic dependency on {} for {}",
+                                    name,
+                                    &cargo[pkg].name
+                                )
                             }
                         }
                     }
@@ -500,12 +451,10 @@ impl ProjectWorkspace {
                 // target of downstream.
                 for pkg in cargo.packages() {
                     for dep in cargo[pkg].dependencies.iter() {
+                        let name = CrateName::new(&dep.name).unwrap();
                         if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
                             for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                                if crate_graph
-                                    .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
-                                    .is_err()
-                                {
+                                if let Err(_) = crate_graph.add_dep(from, name.clone(), to) {
                                     log::error!(
                                         "cyclic dependency {} -> {}",
                                         &cargo[pkg].name,
@@ -563,3 +512,51 @@ fn utf8_stdout(mut cmd: Command) -> Result<String> {
     let stdout = String::from_utf8(output.stdout)?;
     Ok(stdout.trim().to_string())
 }
+
+fn sysroot_to_crate_graph(
+    crate_graph: &mut CrateGraph,
+    sysroot: &Sysroot,
+    target: Option<&str>,
+    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
+) -> (Vec<(CrateName, CrateId)>, Option<CrateId>) {
+    let mut cfg_options = CfgOptions::default();
+    cfg_options.extend(get_rustc_cfg_options(target));
+    let sysroot_crates: FxHashMap<_, _> = sysroot
+        .crates()
+        .filter_map(|krate| {
+            let file_id = load(&sysroot[krate].root)?;
+
+            let env = Env::default();
+            let proc_macro = vec![];
+            let name = sysroot[krate].name.clone();
+            let crate_id = crate_graph.add_crate_root(
+                file_id,
+                Edition::Edition2018,
+                Some(name),
+                cfg_options.clone(),
+                env,
+                proc_macro,
+            );
+            Some((krate, crate_id))
+        })
+        .collect();
+
+    for from in sysroot.crates() {
+        for &to in sysroot[from].deps.iter() {
+            let name = CrateName::new(&sysroot[to].name).unwrap();
+            if let (Some(&from), Some(&to)) = (sysroot_crates.get(&from), sysroot_crates.get(&to)) {
+                if let Err(_) = crate_graph.add_dep(from, name, to) {
+                    log::error!("cyclic dependency between sysroot crates")
+                }
+            }
+        }
+    }
+
+    let public_deps = sysroot
+        .public_deps()
+        .map(|(name, idx)| (CrateName::new(name).unwrap(), sysroot_crates[&idx]))
+        .collect::<Vec<_>>();
+
+    let libproc_macro = sysroot.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
+    (public_deps, libproc_macro)
+}
diff --git a/crates/project_model/src/project_json.rs b/crates/project_model/src/project_json.rs
index 060ea5b7d..5a0fe749a 100644
--- a/crates/project_model/src/project_json.rs
+++ b/crates/project_model/src/project_json.rs
@@ -7,12 +7,13 @@ use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
 use serde::{de, Deserialize};
 
-use crate::cfg_flag::CfgFlag;
+use crate::{cfg_flag::CfgFlag, Sysroot};
 
 /// Roots and crates that compose this Rust project.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ProjectJson {
-    pub(crate) crates: Vec<Crate>,
+    pub(crate) sysroot: Option<Sysroot>,
+    crates: Vec<Crate>,
 }
 
 /// A crate points to the root module of a crate and lists the dependencies of the crate. This is
@@ -34,6 +35,7 @@ pub struct Crate {
 impl ProjectJson {
     pub fn new(base: &AbsPath, data: ProjectJsonData) -> ProjectJson {
         ProjectJson {
+            sysroot: data.sysroot_src.map(|it| base.join(it)).map(|it| Sysroot::load(&it)),
             crates: data
                 .crates
                 .into_iter()
@@ -43,11 +45,13 @@ impl ProjectJson {
                             && !crate_data.root_module.starts_with("..")
                             || crate_data.root_module.starts_with(base)
                     });
-                    let root_module = base.join(crate_data.root_module);
+                    let root_module = base.join(crate_data.root_module).normalize();
                     let (include, exclude) = match crate_data.source {
                         Some(src) => {
                             let absolutize = |dirs: Vec<PathBuf>| {
-                                dirs.into_iter().map(|it| base.join(it)).collect::<Vec<_>>()
+                                dirs.into_iter()
+                                    .map(|it| base.join(it).normalize())
+                                    .collect::<Vec<_>>()
                             };
                             (absolutize(src.include_dirs), absolutize(src.exclude_dirs))
                         }
@@ -79,10 +83,17 @@ impl ProjectJson {
                 .collect::<Vec<_>>(),
         }
     }
+    pub fn n_crates(&self) -> usize {
+        self.crates.len()
+    }
+    pub fn crates(&self) -> impl Iterator<Item = (CrateId, &Crate)> + '_ {
+        self.crates.iter().enumerate().map(|(idx, krate)| (CrateId(idx as u32), krate))
+    }
 }
 
 #[derive(Deserialize)]
 pub struct ProjectJsonData {
+    sysroot_src: Option<PathBuf>,
     crates: Vec<CrateData>,
 }
 
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index 687e15337..74c0eda9a 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -34,16 +34,10 @@ impl ops::Index<SysrootCrate> for Sysroot {
 }
 
 impl Sysroot {
-    pub fn core(&self) -> Option<SysrootCrate> {
-        self.by_name("core")
-    }
-
-    pub fn alloc(&self) -> Option<SysrootCrate> {
-        self.by_name("alloc")
-    }
-
-    pub fn std(&self) -> Option<SysrootCrate> {
-        self.by_name("std")
+    pub fn public_deps(&self) -> impl Iterator<Item = (&'static str, SysrootCrate)> + '_ {
+        // core is added as a dependency before std in order to
+        // mimic rustcs dependency order
+        vec!["core", "alloc", "std"].into_iter().filter_map(move |it| Some((it, self.by_name(it)?)))
     }
 
     pub fn proc_macro(&self) -> Option<SysrootCrate> {
@@ -81,7 +75,7 @@ impl Sysroot {
             }
         }
 
-        if let Some(std) = sysroot.std() {
+        if let Some(std) = sysroot.by_name("std") {
             for dep in STD_DEPS.trim().lines() {
                 if let Some(dep) = sysroot.by_name(dep) {
                     sysroot.crates[std].deps.push(dep)
@@ -89,8 +83,8 @@ impl Sysroot {
             }
         }
 
-        if let Some(alloc) = sysroot.alloc() {
-            if let Some(core) = sysroot.core() {
+        if let Some(alloc) = sysroot.by_name("alloc") {
+            if let Some(core) = sysroot.by_name("core") {
                 sysroot.crates[alloc].deps.push(core);
             }
         }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 0bc92431a..8ddf1e031 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -3,9 +3,9 @@
 //! If run started args, we run the LSP server loop. With a subcommand, we do a
 //! one-time batch processing.
 
-use std::{env, fmt::Write, path::PathBuf};
+use std::{env, path::PathBuf};
 
-use anyhow::{bail, Result};
+use anyhow::{bail, format_err, Result};
 use pico_args::Arguments;
 use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
 use ssr::{SsrPattern, SsrRule};
@@ -13,47 +13,107 @@ use vfs::AbsPathBuf;
 
 pub(crate) struct Args {
     pub(crate) verbosity: Verbosity,
+    pub(crate) log_file: Option<PathBuf>,
     pub(crate) command: Command,
 }
 
 pub(crate) enum Command {
-    Parse {
-        no_dump: bool,
-    },
+    Parse { no_dump: bool },
     Symbols,
-    Highlight {
-        rainbow: bool,
-    },
+    Highlight { rainbow: bool },
     AnalysisStats(AnalysisStatsCmd),
     Bench(BenchCmd),
-    Diagnostics {
-        path: PathBuf,
-        load_output_dirs: bool,
-        with_proc_macro: bool,
-        /// Include files which are not modules. In rust-analyzer
-        /// this would include the parser test files.
-        all: bool,
-    },
-    Ssr {
-        rules: Vec<SsrRule>,
-    },
-    StructuredSearch {
-        debug_snippet: Option<String>,
-        patterns: Vec<SsrPattern>,
-    },
+    Diagnostics { path: PathBuf, load_output_dirs: bool, with_proc_macro: bool },
+    Ssr { rules: Vec<SsrRule> },
+    StructuredSearch { debug_snippet: Option<String>, patterns: Vec<SsrPattern> },
     ProcMacro,
     RunServer,
     Version,
     Help,
 }
 
+const HELP: &str = "\
+rust-analyzer
+
+USAGE:
+    rust-analyzer [FLAGS] [COMMAND] [COMMAND_OPTIONS]
+
+FLAGS:
+    --version         Print version
+    -h, --help        Print this help
+
+    -v,  --verbose
+    -vv, --spammy
+    -q,  --quiet      Set verbosity
+
+    --log-file <PATH> Log to the specified filed instead of stderr
+
+ENVIRONMENTAL VARIABLES:
+    RA_LOG            Set log filter in env_logger format
+    RA_PROFILE        Enable hierarchical profiler
+
+COMMANDS:
+
+not specified         Launch LSP server
+
+parse < main.rs       Parse tree
+    --no-dump         Suppress printing
+
+symbols < main.rs     Parse input an print the list of symbols
+
+highlight < main.rs   Highlight input as html
+    --rainbow         Enable rainbow highlighting of identifiers
+
+analysis-stats <PATH> Batch typecheck project and print summary statistics
+    <PATH>            Directory with Cargo.toml
+    --randomize       Randomize order in which crates, modules, and items are processed
+    --parallel        Run type inference in parallel
+    --memory-usage    Collect memory usage statistics
+    -o, --only <PATH> Only analyze items matching this path
+    --with-deps       Also analyze all dependencies
+    --load-output-dirs
+                      Load OUT_DIR values by running `cargo check` before analysis
+    --with-proc-macro Use proc-macro-srv for proc-macro expanding
+
+analysis-bench <PATH> Benchmark specific analysis operation
+    <PATH>            Directory with Cargo.toml
+    --highlight <PATH>
+                      Compute syntax highlighting for this file
+    --complete <PATH:LINE:COLUMN>
+                      Compute completions at this location
+    --goto-def <PATH:LINE:COLUMN>
+                      Compute goto definition at this location
+    --memory-usage    Collect memory usage statistics
+    --load-output-dirs
+                      Load OUT_DIR values by running `cargo check` before analysis
+    --with-proc-macro Use proc-macro-srv for proc-macro expanding
+
+diagnostics <PATH>
+    <PATH>            Directory with Cargo.toml
+    --load-output-dirs
+                      Load OUT_DIR values by running `cargo check` before analysis
+    --with-proc-macro Use proc-macro-srv for proc-macro expanding
+
+ssr [RULE...]
+    <RULE>            A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
+
+search [PATTERN..]
+    <PATTERN>         A structured search replace pattern (`$a.foo($b)`)
+    --debug <snippet> Prints debug information for any nodes with source exactly
+                      equal to <snippet>
+";
+
 impl Args {
     pub(crate) fn parse() -> Result<Args> {
         let mut matches = Arguments::from_env();
 
         if matches.contains("--version") {
-            matches.finish().or_else(handle_extra_flags)?;
-            return Ok(Args { verbosity: Verbosity::Normal, command: Command::Version });
+            matches.finish()?;
+            return Ok(Args {
+                verbosity: Verbosity::Normal,
+                log_file: None,
+                command: Command::Version,
+            });
         }
 
         let verbosity = match (
@@ -68,320 +128,96 @@ impl Args {
             (false, true, false) => Verbosity::Verbose,
             (false, true, true) => bail!("Invalid flags: -q conflicts with -v"),
         };
+        let log_file = matches.opt_value_from_str("--log-file")?;
+
+        if matches.contains(["-h", "--help"]) {
+            eprintln!("{}", HELP);
+            return Ok(Args { verbosity, log_file: None, command: Command::Help });
+        }
 
-        let help = Ok(Args { verbosity, command: Command::Help });
         let subcommand = match matches.subcommand()? {
             Some(it) => it,
             None => {
-                if matches.contains(["-h", "--help"]) {
-                    print_subcommands();
-                    return help;
-                }
-                matches.finish().or_else(handle_extra_flags)?;
-                return Ok(Args { verbosity, command: Command::RunServer });
+                matches.finish()?;
+                return Ok(Args { verbosity, log_file, command: Command::RunServer });
             }
         };
         let command = match subcommand.as_str() {
-            "parse" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer parse
-
-USAGE:
-    rust-analyzer parse [FLAGS]
-
-FLAGS:
-    -h, --help       Prints help information
-        --no-dump"
-                    );
-                    return help;
-                }
-
-                let no_dump = matches.contains("--no-dump");
-                matches.finish().or_else(handle_extra_flags)?;
-                Command::Parse { no_dump }
-            }
-            "symbols" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer symbols
-
-USAGE:
-    rust-analyzer highlight [FLAGS]
-
-FLAGS:
-    -h, --help    Prints help inforamtion"
-                    );
-                    return help;
-                }
-
-                matches.finish().or_else(handle_extra_flags)?;
-
-                Command::Symbols
-            }
-            "highlight" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer highlight
-
-USAGE:
-    rust-analyzer highlight [FLAGS]
-
-FLAGS:
-    -h, --help       Prints help information
-    -r, --rainbow"
-                    );
-                    return help;
-                }
-
-                let rainbow = matches.contains(["-r", "--rainbow"]);
-                matches.finish().or_else(handle_extra_flags)?;
-                Command::Highlight { rainbow }
-            }
-            "analysis-stats" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer analysis-stats
-
-USAGE:
-    rust-analyzer analysis-stats [FLAGS] [OPTIONS] [PATH]
-
-FLAGS:
-    -o, --only              Only analyze items matching this path
-    -h, --help              Prints help information
-        --memory-usage      Collect memory usage statistics
-        --randomize         Randomize order in which crates, modules, and items are processed
-        --parallel          Run type inference in parallel
-        --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
-        --with-proc-macro   Use ra-proc-macro-srv for proc-macro expanding
-        --with-deps         Also analyze all dependencies
-    -v, --verbose
-    -q, --quiet
-
-OPTIONS:
-    -o <ONLY>
-
-ARGS:
-    <PATH>"
-                    );
-                    return help;
-                }
-
-                let randomize = matches.contains("--randomize");
-                let parallel = matches.contains("--parallel");
-                let memory_usage = matches.contains("--memory-usage");
-                let only: Option<String> = matches.opt_value_from_str(["-o", "--only"])?;
-                let with_deps: bool = matches.contains("--with-deps");
-                let load_output_dirs = matches.contains("--load-output-dirs");
-                let with_proc_macro = matches.contains("--with-proc-macro");
-                let path = {
-                    let mut trailing = matches.free()?;
-                    if trailing.len() != 1 {
-                        bail!("Invalid flags");
-                    }
-                    trailing.pop().unwrap().into()
-                };
-
-                Command::AnalysisStats(AnalysisStatsCmd {
-                    randomize,
-                    parallel,
-                    memory_usage,
-                    only,
-                    with_deps,
-                    path,
-                    load_output_dirs,
-                    with_proc_macro,
-                })
-            }
-            "analysis-bench" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer analysis-bench
-
-USAGE:
-    rust-analyzer analysis-bench [FLAGS] [OPTIONS]
-
-FLAGS:
-    -h, --help          Prints help information
-    --memory-usage      Collect memory usage statistics
-    --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro   Use ra-proc-macro-srv for proc-macro expanding
-    -v, --verbose
-
-OPTIONS:
-    --project <PATH>                 Path to directory with Cargo.toml
-    --complete <PATH:LINE:COLUMN>    Compute completions at this location
-    --goto-def <PATH:LINE:COLUMN>    Compute goto definition at this location
-    --highlight <PATH>               Hightlight this file
-
-ARGS:
-    <PATH>    Project to analyse"
-                    );
-                    return help;
-                }
-
-                let path: PathBuf = matches.opt_value_from_str("--project")?.unwrap_or_default();
-                let highlight_path: Option<String> = matches.opt_value_from_str("--highlight")?;
-                let complete_path: Option<Position> = matches.opt_value_from_str("--complete")?;
-                let goto_def_path: Option<Position> = matches.opt_value_from_str("--goto-def")?;
-                let what = match (highlight_path, complete_path, goto_def_path) {
-                    (Some(path), None, None) => {
-                        let path = env::current_dir().unwrap().join(path);
-                        BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
+            "parse" => Command::Parse { no_dump: matches.contains("--no-dump") },
+            "symbols" => Command::Symbols,
+            "highlight" => Command::Highlight { rainbow: matches.contains("--rainbow") },
+            "analysis-stats" => Command::AnalysisStats(AnalysisStatsCmd {
+                randomize: matches.contains("--randomize"),
+                parallel: matches.contains("--parallel"),
+                memory_usage: matches.contains("--memory-usage"),
+                only: matches.opt_value_from_str(["-o", "--only"])?,
+                with_deps: matches.contains("--with-deps"),
+                load_output_dirs: matches.contains("--load-output-dirs"),
+                with_proc_macro: matches.contains("--with-proc-macro"),
+                path: matches
+                    .free_from_str()?
+                    .ok_or_else(|| format_err!("expected positional argument"))?,
+            }),
+            "analysis-bench" => Command::Bench(BenchCmd {
+                what: {
+                    let highlight_path: Option<String> =
+                        matches.opt_value_from_str("--highlight")?;
+                    let complete_path: Option<Position> =
+                        matches.opt_value_from_str("--complete")?;
+                    let goto_def_path: Option<Position> =
+                        matches.opt_value_from_str("--goto-def")?;
+                    match (highlight_path, complete_path, goto_def_path) {
+                            (Some(path), None, None) => {
+                                let path = env::current_dir().unwrap().join(path);
+                                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
+                            }
+                            (None, Some(position), None) => BenchWhat::Complete(position),
+                            (None, None, Some(position)) => BenchWhat::GotoDef(position),
+                            _ => panic!(
+                                "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
+                            ),
+                        }
+                },
+                memory_usage: matches.contains("--memory-usage"),
+                load_output_dirs: matches.contains("--load-output-dirs"),
+                with_proc_macro: matches.contains("--with-proc-macro"),
+                path: matches
+                    .free_from_str()?
+                    .ok_or_else(|| format_err!("expected positional argument"))?,
+            }),
+            "diagnostics" => Command::Diagnostics {
+                load_output_dirs: matches.contains("--load-output-dirs"),
+                with_proc_macro: matches.contains("--with-proc-macro"),
+                path: matches
+                    .free_from_str()?
+                    .ok_or_else(|| format_err!("expected positional argument"))?,
+            },
+            "proc-macro" => Command::ProcMacro,
+            "ssr" => Command::Ssr {
+                rules: {
+                    let mut acc = Vec::new();
+                    while let Some(rule) = matches.free_from_str()? {
+                        acc.push(rule);
                     }
-                    (None, Some(position), None) => BenchWhat::Complete(position),
-                    (None, None, Some(position)) => BenchWhat::GotoDef(position),
-                    _ => panic!(
-                        "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
-                    ),
-                };
-                let memory_usage = matches.contains("--memory-usage");
-                let load_output_dirs = matches.contains("--load-output-dirs");
-                let with_proc_macro = matches.contains("--with-proc-macro");
-                Command::Bench(BenchCmd {
-                    memory_usage,
-                    path,
-                    what,
-                    load_output_dirs,
-                    with_proc_macro,
-                })
-            }
-            "diagnostics" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer diagnostics
-
-USAGE:
-    rust-analyzer diagnostics [FLAGS] [PATH]
-
-FLAGS:
-    -h, --help              Prints help information
-        --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
-        --all               Include all files rather than only modules
-
-ARGS:
-    <PATH>"
-                    );
-                    return help;
-                }
-
-                let load_output_dirs = matches.contains("--load-output-dirs");
-                let with_proc_macro = matches.contains("--with-proc-macro");
-                let all = matches.contains("--all");
-                let path = {
-                    let mut trailing = matches.free()?;
-                    if trailing.len() != 1 {
-                        bail!("Invalid flags");
+                    acc
+                },
+            },
+            "search" => Command::StructuredSearch {
+                debug_snippet: matches.opt_value_from_str("--debug")?,
+                patterns: {
+                    let mut acc = Vec::new();
+                    while let Some(rule) = matches.free_from_str()? {
+                        acc.push(rule);
                     }
-                    trailing.pop().unwrap().into()
-                };
-
-                Command::Diagnostics { path, load_output_dirs, with_proc_macro, all }
-            }
-            "proc-macro" => Command::ProcMacro,
-            "ssr" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer ssr
-
-USAGE:
-    rust-analyzer ssr [FLAGS] [RULE...]
-
-EXAMPLE:
-    rust-analyzer ssr '$a.foo($b) ==> bar($a, $b)'
-
-FLAGS:
-    --debug <snippet>   Prints debug information for any nodes with source exactly equal to <snippet>
-    -h, --help          Prints help information
-
-ARGS:
-    <RULE>              A structured search replace rule"
-                    );
-                    return help;
-                }
-                let mut rules = Vec::new();
-                while let Some(rule) = matches.free_from_str()? {
-                    rules.push(rule);
-                }
-                Command::Ssr { rules }
-            }
-            "search" => {
-                if matches.contains(["-h", "--help"]) {
-                    eprintln!(
-                        "\
-rust-analyzer search
-
-USAGE:
-    rust-analyzer search [FLAGS] [PATTERN...]
-
-EXAMPLE:
-    rust-analyzer search '$a.foo($b)'
-
-FLAGS:
-    --debug <snippet>   Prints debug information for any nodes with source exactly equal to <snippet>
-    -h, --help          Prints help information
-
-ARGS:
-    <PATTERN>           A structured search pattern"
-                    );
-                    return help;
-                }
-                let debug_snippet = matches.opt_value_from_str("--debug")?;
-                let mut patterns = Vec::new();
-                while let Some(rule) = matches.free_from_str()? {
-                    patterns.push(rule);
-                }
-                Command::StructuredSearch { patterns, debug_snippet }
-            }
+                    acc
+                },
+            },
             _ => {
-                print_subcommands();
-                return help;
+                eprintln!("{}", HELP);
+                return Ok(Args { verbosity, log_file: None, command: Command::Help });
             }
         };
-        Ok(Args { verbosity, command })
-    }
-}
-
-fn print_subcommands() {
-    eprintln!(
-        "\
-rust-analyzer
-
-USAGE:
-    rust-analyzer <SUBCOMMAND>
-
-FLAGS:
-    -h, --help        Prints help information
-
-SUBCOMMANDS:
-    analysis-bench
-    analysis-stats
-    highlight
-    diagnostics
-    proc-macro
-    parse
-    search
-    ssr
-    symbols"
-    )
-}
-
-fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
-    if let pico_args::Error::UnusedArgsLeft(flags) = e {
-        let mut invalid_flags = String::new();
-        for flag in flags {
-            write!(&mut invalid_flags, "{}, ", flag)?;
-        }
-        let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
-        bail!("Invalid flags: {}", invalid_flags);
-    } else {
-        bail!(e);
+        matches.finish()?;
+        Ok(Args { verbosity, log_file, command })
     }
 }
diff --git a/crates/rust-analyzer/src/bin/logger.rs b/crates/rust-analyzer/src/bin/logger.rs
new file mode 100644
index 000000000..3bcb1ae37
--- /dev/null
+++ b/crates/rust-analyzer/src/bin/logger.rs
@@ -0,0 +1,73 @@
+//! Simple logger that logs either to stderr or to a file, using `env_logger`
+//! filter syntax. Amusingly, there's no crates.io crate that can do this and
+//! only this.
+
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+};
+
+use env_logger::filter::{Builder, Filter};
+use log::{Log, Metadata, Record};
+use parking_lot::Mutex;
+
+pub(crate) struct Logger {
+    filter: Filter,
+    file: Option<Mutex<BufWriter<File>>>,
+}
+
+impl Logger {
+    pub(crate) fn new(log_file: Option<File>, filter: Option<&str>) -> Logger {
+        let filter = {
+            let mut builder = Builder::new();
+            if let Some(filter) = filter {
+                builder.parse(filter);
+            }
+            builder.build()
+        };
+
+        let file = log_file.map(|it| Mutex::new(BufWriter::new(it)));
+
+        Logger { filter, file }
+    }
+
+    pub(crate) fn install(self) {
+        let max_level = self.filter.filter();
+        let _ = log::set_boxed_logger(Box::new(self)).map(|()| log::set_max_level(max_level));
+    }
+}
+
+impl Log for Logger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        self.filter.enabled(metadata)
+    }
+
+    fn log(&self, record: &Record) {
+        if !self.filter.matches(record) {
+            return;
+        }
+        match &self.file {
+            Some(w) => {
+                let _ = writeln!(
+                    w.lock(),
+                    "[{} {}] {}",
+                    record.level(),
+                    record.module_path().unwrap_or_default(),
+                    record.args(),
+                );
+            }
+            None => eprintln!(
+                "[{} {}] {}",
+                record.level(),
+                record.module_path().unwrap_or_default(),
+                record.args(),
+            ),
+        }
+    }
+
+    fn flush(&self) {
+        if let Some(w) = &self.file {
+            let _ = w.lock().flush();
+        }
+    }
+}
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 0e03a0ca8..ba4402ade 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -2,8 +2,9 @@
 //!
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
 mod args;
+mod logger;
 
-use std::{convert::TryFrom, process};
+use std::{convert::TryFrom, env, fs, path::PathBuf, process};
 
 use lsp_server::Connection;
 use project_model::ProjectManifest;
@@ -26,8 +27,8 @@ fn main() {
 }
 
 fn try_main() -> Result<()> {
-    setup_logging()?;
     let args = args::Args::parse()?;
+    setup_logging(args.log_file)?;
     match args.command {
         args::Command::RunServer => run_server()?,
         args::Command::ProcMacro => proc_macro_srv::cli::run()?,
@@ -37,8 +38,8 @@ fn try_main() -> Result<()> {
         args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
         args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
         args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro, all } => {
-            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro, all)?
+        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
+            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
         }
         args::Command::Ssr { rules } => {
             cli::apply_ssr_rules(rules)?;
@@ -52,9 +53,21 @@ fn try_main() -> Result<()> {
     Ok(())
 }
 
-fn setup_logging() -> Result<()> {
-    std::env::set_var("RUST_BACKTRACE", "short");
-    env_logger::try_init_from_env("RA_LOG")?;
+fn setup_logging(log_file: Option<PathBuf>) -> Result<()> {
+    env::set_var("RUST_BACKTRACE", "short");
+
+    let log_file = match log_file {
+        Some(path) => {
+            if let Some(parent) = path.parent() {
+                let _ = fs::create_dir_all(parent);
+            }
+            Some(fs::File::create(path)?)
+        }
+        None => None,
+    };
+    let filter = env::var("RA_LOG").ok();
+    logger::Logger::new(log_file, filter.as_deref()).install();
+
     profile::init();
     Ok(())
 }
@@ -95,7 +108,7 @@ fn run_server() -> Result<()> {
         {
             Some(it) => it,
             None => {
-                let cwd = std::env::current_dir()?;
+                let cwd = env::current_dir()?;
                 AbsPathBuf::assert(cwd)
             }
         };
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index c424aa6e2..f3b6c900e 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -12,12 +12,7 @@ use ide::{DiagnosticsConfig, Severity};
 
 use crate::cli::{load_cargo::load_cargo, Result};
 
-pub fn diagnostics(
-    path: &Path,
-    load_output_dirs: bool,
-    with_proc_macro: bool,
-    _all: bool,
-) -> Result<()> {
+pub fn diagnostics(path: &Path, load_output_dirs: bool, with_proc_macro: bool) -> Result<()> {
     let (host, _vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
     let db = host.raw_database();
     let analysis = host.analysis();
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index e97784c47..0880d0425 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -39,7 +39,6 @@ fn completes_items_from_standard_library() {
         return;
     }
 
-    let project_start = Instant::now();
     let server = Project::with_fixture(
         r#"
 //- /Cargo.toml
@@ -52,10 +51,9 @@ use std::collections::Spam;
 "#,
     )
     .with_sysroot(true)
-    .server();
-    server.wait_until_workspace_is_loaded();
-    eprintln!("loading took    {:?}", project_start.elapsed());
-    let completion_start = Instant::now();
+    .server()
+    .wait_until_workspace_is_loaded();
+
     let res = server.send_request::<Completion>(CompletionParams {
         text_document_position: TextDocumentPositionParams::new(
             server.doc_id("src/lib.rs"),
@@ -66,7 +64,6 @@ use std::collections::Spam;
         work_done_progress_params: WorkDoneProgressParams::default(),
     });
     assert!(res.to_string().contains("HashMap"));
-    eprintln!("completion took {:?}", completion_start.elapsed());
 }
 
 #[test]
@@ -75,7 +72,8 @@ fn test_runnables_project() {
         return;
     }
 
-    let code = r#"
+    let server = Project::with_fixture(
+        r#"
 //- /foo/Cargo.toml
 [package]
 name = "foo"
@@ -95,11 +93,13 @@ version = "0.0.0"
 
 //- /bar/src/main.rs
 fn main() {}
-"#;
-
-    let server = Project::with_fixture(code).root("foo").root("bar").server();
+"#,
+    )
+    .root("foo")
+    .root("bar")
+    .server()
+    .wait_until_workspace_is_loaded();
 
-    server.wait_until_workspace_is_loaded();
     server.request::<Runnables>(
         RunnablesParams { text_document: server.doc_id("foo/tests/spam.rs"), position: None },
         json!([
@@ -166,8 +166,8 @@ fn main() {
 
 pub use std::collections::HashMap;
 "#,
-    );
-    server.wait_until_workspace_is_loaded();
+    )
+    .wait_until_workspace_is_loaded();
 
     server.request::<Formatting>(
         DocumentFormattingParams {
@@ -224,8 +224,8 @@ fn main() {
 
 pub use std::collections::HashMap;
 "#,
-    );
-    server.wait_until_workspace_is_loaded();
+    )
+    .wait_until_workspace_is_loaded();
 
     server.request::<Formatting>(
         DocumentFormattingParams {
@@ -277,14 +277,14 @@ mod bar;
 
 fn main() {}
 "#,
-    );
-    server.wait_until_workspace_is_loaded();
-    let empty_context = || CodeActionContext { diagnostics: Vec::new(), only: None };
+    )
+    .wait_until_workspace_is_loaded();
+
     server.request::<CodeActionRequest>(
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
             range: Range::new(Position::new(0, 4), Position::new(0, 7)),
-            context: empty_context(),
+            context: CodeActionContext::default(),
             partial_result_params: PartialResultParams::default(),
             work_done_progress_params: WorkDoneProgressParams::default(),
         },
@@ -307,7 +307,7 @@ fn main() {}
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
             range: Range::new(Position::new(2, 4), Position::new(2, 7)),
-            context: empty_context(),
+            context: CodeActionContext::default(),
             partial_result_params: PartialResultParams::default(),
             work_done_progress_params: WorkDoneProgressParams::default(),
         },
@@ -348,15 +348,14 @@ fn main() {{}}
         PROJECT = project.to_string(),
     );
 
-    let server = Project::with_fixture(&code).tmp_dir(tmp_dir).server();
+    let server =
+        Project::with_fixture(&code).tmp_dir(tmp_dir).server().wait_until_workspace_is_loaded();
 
-    server.wait_until_workspace_is_loaded();
-    let empty_context = || CodeActionContext { diagnostics: Vec::new(), only: None };
     server.request::<CodeActionRequest>(
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
             range: Range::new(Position::new(0, 4), Position::new(0, 7)),
-            context: empty_context(),
+            context: CodeActionContext::default(),
             partial_result_params: PartialResultParams::default(),
             work_done_progress_params: WorkDoneProgressParams::default(),
         },
@@ -379,7 +378,7 @@ fn main() {{}}
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
             range: Range::new(Position::new(2, 4), Position::new(2, 7)),
-            context: empty_context(),
+            context: CodeActionContext::default(),
             partial_result_params: PartialResultParams::default(),
             work_done_progress_params: WorkDoneProgressParams::default(),
         },
@@ -412,9 +411,9 @@ fn main() {{}}
         librs, libs
     ))
     .with_sysroot(true)
-    .server();
+    .server()
+    .wait_until_workspace_is_loaded();
 
-    server.wait_until_workspace_is_loaded();
     for i in 0..10 {
         server.notification::<DidOpenTextDocument>(DidOpenTextDocumentParams {
             text_document: TextDocumentItem {
@@ -425,7 +424,7 @@ fn main() {{}}
             },
         });
     }
-    let start = std::time::Instant::now();
+    let start = Instant::now();
     server.request::<OnEnter>(
         TextDocumentPositionParams {
             text_document: server.doc_id("src/m0.rs"),
@@ -461,8 +460,8 @@ version = \"0.0.0\"
 /// Some Docs\r\nfn main() {}
 ",
     )
-    .server();
-    server.wait_until_workspace_is_loaded();
+    .server()
+    .wait_until_workspace_is_loaded();
 
     server.request::<OnEnter>(
         TextDocumentPositionParams {
@@ -536,8 +535,9 @@ fn main() {
     .with_config(|config| {
         config.cargo.load_out_dirs_from_check = true;
     })
-    .server();
-    server.wait_until_workspace_is_loaded();
+    .server()
+    .wait_until_workspace_is_loaded();
+
     let res = server.send_request::<HoverRequest>(HoverParams {
         text_document_position_params: TextDocumentPositionParams::new(
             server.doc_id("src/main.rs"),
@@ -546,6 +546,7 @@ fn main() {
         work_done_progress_params: Default::default(),
     });
     assert!(res.to_string().contains("&str"));
+
     let res = server.send_request::<HoverRequest>(HoverParams {
         text_document_position_params: TextDocumentPositionParams::new(
             server.doc_id("src/main.rs"),
@@ -554,6 +555,7 @@ fn main() {
         work_done_progress_params: Default::default(),
     });
     assert!(res.to_string().contains("&str"));
+
     server.request::<GotoTypeDefinition>(
         GotoDefinitionParams {
             text_document_position_params: TextDocumentPositionParams::new(
@@ -579,6 +581,7 @@ fn main() {
             "targetUri": "file:///[..]src/main.rs"
         }]),
     );
+
     server.request::<GotoTypeDefinition>(
         GotoDefinitionParams {
             text_document_position_params: TextDocumentPositionParams::new(
@@ -611,6 +614,7 @@ fn resolve_proc_macro() {
     if skip_slow_tests() {
         return;
     }
+
     let server = Project::with_fixture(
         r###"
 //- /foo/Cargo.toml
@@ -679,8 +683,9 @@ pub fn foo(_input: TokenStream) -> TokenStream {
     })
     .root("foo")
     .root("bar")
-    .server();
-    server.wait_until_workspace_is_loaded();
+    .server()
+    .wait_until_workspace_is_loaded();
+
     let res = server.send_request::<HoverRequest>(HoverParams {
         text_document_position_params: TextDocumentPositionParams::new(
             server.doc_id("foo/src/main.rs"),
@@ -688,7 +693,6 @@ pub fn foo(_input: TokenStream) -> TokenStream {
         ),
         work_done_progress_params: Default::default(),
     });
-
     let value = res.get("contents").unwrap().get("value").unwrap().to_string();
     assert_eq!(value, r#""\n```rust\nfoo::Bar\n```\n\n```rust\nfn bar()\n```""#)
 }
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 5bafeba79..784cbda79 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -202,7 +202,7 @@ impl Server {
         }
         panic!("no response");
     }
-    pub fn wait_until_workspace_is_loaded(&self) {
+    pub fn wait_until_workspace_is_loaded(self) -> Server {
         self.wait_for_message_cond(1, &|msg: &Message| match msg {
             Message::Notification(n) if n.method == "$/progress" => {
                 match n.clone().extract::<ProgressParams>("$/progress").unwrap() {
@@ -214,7 +214,8 @@ impl Server {
                 }
             }
             _ => false,
-        })
+        });
+        self
     }
     fn wait_for_message_cond(&self, n: usize, cond: &dyn Fn(&Message) -> bool) {
         let mut total = 0;
diff --git a/crates/text_edit/src/lib.rs b/crates/text_edit/src/lib.rs
index ab8cd7fd1..e417e8ea6 100644
--- a/crates/text_edit/src/lib.rs
+++ b/crates/text_edit/src/lib.rs
@@ -159,13 +159,13 @@ impl<'a> IntoIterator for &'a TextEdit {
 
 impl TextEditBuilder {
     pub fn replace(&mut self, range: TextRange, replace_with: String) {
-        self.indels.push(Indel::replace(range, replace_with))
+        self.indel(Indel::replace(range, replace_with))
     }
     pub fn delete(&mut self, range: TextRange) {
-        self.indels.push(Indel::delete(range))
+        self.indel(Indel::delete(range))
     }
     pub fn insert(&mut self, offset: TextSize, text: String) {
-        self.indels.push(Indel::insert(offset, text))
+        self.indel(Indel::insert(offset, text))
     }
     pub fn finish(self) -> TextEdit {
         let mut indels = self.indels;
@@ -175,6 +175,12 @@ impl TextEditBuilder {
     pub fn invalidates_offset(&self, offset: TextSize) -> bool {
         self.indels.iter().any(|indel| indel.delete.contains_inclusive(offset))
     }
+    fn indel(&mut self, indel: Indel) {
+        self.indels.push(indel);
+        if self.indels.len() <= 16 {
+            check_disjoint(&mut self.indels);
+        }
+    }
 }
 
 fn check_disjoint(indels: &mut [impl std::borrow::Borrow<Indel>]) -> bool {