32 files changed, 228 insertions, 188 deletions

diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 1f1dcea42..1b4b47215 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -3,7 +3,7 @@
 //! derived from this input.
 //!
 //! Note that neither this module, nor any other part of the analyzer's core do
-//! actual IO. See `vfs` and `project_model` in the `ra_lsp_server` crate for how
+//! actual IO. See `vfs` and `project_model` in the `rust-analyzer` crate for how
 //! actual IO is done and lowered to input.
 
 use std::{fmt, str::FromStr};
diff --git a/crates/ra_ide_db/src/feature_flags.rs b/crates/ra_ide_db/src/feature_flags.rs
index 1b3cabf4d..76655f572 100644
--- a/crates/ra_ide_db/src/feature_flags.rs
+++ b/crates/ra_ide_db/src/feature_flags.rs
@@ -13,7 +13,7 @@ use rustc_hash::FxHashMap;
 /// checked at compile time, to keep things simple and flexible.
 ///
 /// Also note that, at the moment, `FeatureFlags` also store features for
-/// `ra_lsp_server`. This should be benign layering violation.
+/// `rust-analyzer`. This should be benign layering violation.
 #[derive(Debug)]
 pub struct FeatureFlags {
     flags: FxHashMap<String, bool>,
diff --git a/crates/ra_lsp_server/src/cargo_target_spec.rs b/crates/ra_lsp_server/src/cargo_target_spec.rs
deleted file mode 100644
index 5fd1e7b6b..000000000
--- a/crates/ra_lsp_server/src/cargo_target_spec.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! FIXME: write short doc here
-
-use ra_ide::{FileId, RunnableKind, TestId};
-use ra_project_model::{self, ProjectWorkspace, TargetKind};
-
-use crate::{world::WorldSnapshot, Result};
-
-pub(crate) fn runnable_args(
-    world: &WorldSnapshot,
-    file_id: FileId,
-    kind: &RunnableKind,
-) -> Result<Vec<String>> {
-    let spec = CargoTargetSpec::for_file(world, file_id)?;
-    let mut res = Vec::new();
-    match kind {
-        RunnableKind::Test { test_id } => {
-            res.push("test".to_string());
-            if let Some(spec) = spec {
-                spec.push_to(&mut res);
-            }
-            res.push("--".to_string());
-            res.push(test_id.to_string());
-            if let TestId::Path(_) = test_id {
-                res.push("--exact".to_string());
-            }
-            res.push("--nocapture".to_string());
-        }
-        RunnableKind::TestMod { path } => {
-            res.push("test".to_string());
-            if let Some(spec) = spec {
-                spec.push_to(&mut res);
-            }
-            res.push("--".to_string());
-            res.push(path.to_string());
-            res.push("--nocapture".to_string());
-        }
-        RunnableKind::Bench { test_id } => {
-            res.push("bench".to_string());
-            if let Some(spec) = spec {
-                spec.push_to(&mut res);
-            }
-            res.push("--".to_string());
-            res.push(test_id.to_string());
-            if let TestId::Path(_) = test_id {
-                res.push("--exact".to_string());
-            }
-            res.push("--nocapture".to_string());
-        }
-        RunnableKind::Bin => {
-            res.push("run".to_string());
-            if let Some(spec) = spec {
-                spec.push_to(&mut res);
-            }
-        }
-    }
-    Ok(res)
-}
-
-pub struct CargoTargetSpec {
-    pub package: String,
-    pub target: String,
-    pub target_kind: TargetKind,
-}
-
-impl CargoTargetSpec {
-    pub fn for_file(world: &WorldSnapshot, file_id: FileId) -> Result<Option<CargoTargetSpec>> {
-        let &crate_id = match world.analysis().crate_for(file_id)?.first() {
-            Some(crate_id) => crate_id,
-            None => return Ok(None),
-        };
-        let file_id = world.analysis().crate_root(crate_id)?;
-        let path = world.file_id_to_path(file_id);
-        let res = world.workspaces.iter().find_map(|ws| match ws {
-            ProjectWorkspace::Cargo { cargo, .. } => {
-                let tgt = cargo.target_by_root(&path)?;
-                Some(CargoTargetSpec {
-                    package: tgt.package(&cargo).name(&cargo).to_string(),
-                    target: tgt.name(&cargo).to_string(),
-                    target_kind: tgt.kind(&cargo),
-                })
-            }
-            ProjectWorkspace::Json { .. } => None,
-        });
-        Ok(res)
-    }
-
-    pub fn push_to(self, buf: &mut Vec<String>) {
-        buf.push("--package".to_string());
-        buf.push(self.package);
-        match self.target_kind {
-            TargetKind::Bin => {
-                buf.push("--bin".to_string());
-                buf.push(self.target);
-            }
-            TargetKind::Test => {
-                buf.push("--test".to_string());
-                buf.push(self.target);
-            }
-            TargetKind::Bench => {
-                buf.push("--bench".to_string());
-                buf.push(self.target);
-            }
-            TargetKind::Example => {
-                buf.push("--example".to_string());
-                buf.push(self.target);
-            }
-            TargetKind::Lib => {
-                buf.push("--lib".to_string());
-            }
-            TargetKind::Other => (),
-        }
-    }
-}
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 7ff8db58a..c267bc85f 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -351,13 +351,13 @@ 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/ra_lsp_server ./out.profile` to see the results.
+/// 5. 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:
 ///
 /// ```bash
 /// $ nix-shell -p gperftools --run \
-///     'cargo run --release -p ra_lsp_server -- parse < ~/projects/rustbench/parser.rs > /dev/null'
+///     'cargo run --release -p rust-analyzer -- parse < ~/projects/rustbench/parser.rs > /dev/null'
 /// ```
 #[derive(Debug)]
 pub struct CpuProfiler {
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index 7b9cc899c..db779a2d2 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -1,10 +1,10 @@
 //! FIXME: write short doc here
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{bail, Context, Result};
 use std::{
     env,
     path::{Path, PathBuf},
-    process::Command,
+    process::{Command, Output},
 };
 
 use ra_arena::{impl_arena_id, Arena, RawId};
@@ -47,18 +47,7 @@ impl Sysroot {
     }
 
     pub fn discover(cargo_toml: &Path) -> Result<Sysroot> {
-        let src = try_find_src_path(cargo_toml)?;
-
-        if !src.exists() {
-            Err(anyhow!(
-                "can't load standard library from sysroot\n\
-                 {}\n\
-                 (discovered via `rustc --print sysroot`)\n\
-                 try running `rustup component add rust-src` or set `RUST_SRC_PATH`",
-                src.display(),
-            ))?;
-        }
-
+        let src = get_or_install_rust_src(cargo_toml)?;
         let mut sysroot = Sysroot { crates: Arena::default() };
         for name in SYSROOT_CRATES.trim().lines() {
             let root = src.join(format!("lib{}", name)).join("lib.rs");
@@ -90,27 +79,54 @@ impl Sysroot {
     }
 }
 
-fn try_find_src_path(cargo_toml: &Path) -> Result<PathBuf> {
-    if let Ok(path) = env::var("RUST_SRC_PATH") {
-        return Ok(path.into());
-    }
+fn create_command_text(program: &str, args: &[&str]) -> String {
+    format!("{} {}", program, args.join(" "))
+}
 
-    let rustc_output = Command::new("rustc")
+fn run_command_in_cargo_dir(cargo_toml: &Path, program: &str, args: &[&str]) -> Result<Output> {
+    let output = Command::new(program)
         .current_dir(cargo_toml.parent().unwrap())
-        .args(&["--print", "sysroot"])
+        .args(args)
         .output()
-        .context("rustc --print sysroot failed")?;
-    if !rustc_output.status.success() {
-        match rustc_output.status.code() {
-            Some(code) => {
-                bail!("failed to locate sysroot: rustc --print sysroot exited with code {}", code)
-            }
-            None => bail!("failed to locate sysroot: rustc --print sysroot terminated by signal"),
+        .context(format!("{} failed", create_command_text(program, args)))?;
+    if !output.status.success() {
+        match output.status.code() {
+            Some(code) => bail!(
+                "failed to run the command: '{}' exited with code {}",
+                create_command_text(program, args),
+                code
+            ),
+            None => bail!(
+                "failed to run the command: '{}' terminated by signal",
+                create_command_text(program, args)
+            ),
         };
     }
+    Ok(output)
+}
+
+fn get_or_install_rust_src(cargo_toml: &Path) -> Result<PathBuf> {
+    if let Ok(path) = env::var("RUST_SRC_PATH") {
+        return Ok(path.into());
+    }
+    let rustc_output = run_command_in_cargo_dir(cargo_toml, "rustc", &["--print", "sysroot"])?;
     let stdout = String::from_utf8(rustc_output.stdout)?;
     let sysroot_path = Path::new(stdout.trim());
-    Ok(sysroot_path.join("lib/rustlib/src/rust/src"))
+    let src_path = sysroot_path.join("lib/rustlib/src/rust/src");
+
+    if !src_path.exists() {
+        run_command_in_cargo_dir(cargo_toml, "rustup", &["component", "add", "rust-src"])?;
+    }
+    if !src_path.exists() {
+        bail!(
+            "can't load standard library from sysroot\n\
+            {}\n\
+            (discovered via `rustc --print sysroot`)\n\
+            try running `rustup component add rust-src` or set `RUST_SRC_PATH`",
+            src_path.display(),
+        )
+    }
+    Ok(src_path)
 }
 
 impl SysrootCrate {
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 83db943fe..cb72972c5 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -22,7 +22,7 @@ ra_text_edit = { path = "../ra_text_edit" }
 ra_parser = { path = "../ra_parser" }
 
 # This crate transitively depends on `smol_str` via `rowan`.
-# ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
+# ideally, `serde` should be enabled by `rust-analyzer`, but we enable it here
 # to reduce number of compilations
 smol_str = { version = "0.1.12", features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
diff --git a/crates/ra_tt/Cargo.toml b/crates/ra_tt/Cargo.toml
index b8dceb92a..c9601fdcc 100644
--- a/crates/ra_tt/Cargo.toml
+++ b/crates/ra_tt/Cargo.toml
@@ -8,6 +8,6 @@ authors = ["rust-analyzer developers"]
 doctest = false
 
 [dependencies]
-# ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
+# ideally, `serde` should be enabled by `rust-analyzer`, but we enable it here
 # to reduce number of compilations
 smol_str = { version = "0.1.12", features = ["serde"] }
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index da523ba8a..3dae43d2a 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -1,12 +1,17 @@
 [package]
 edition = "2018"
-name = "ra_lsp_server"
+name = "rust-analyzer"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+autobins = false
 
 [lib]
 doctest = false
 
+[[bin]]
+name = "rust-analyzer"
+path = "./src/bin/main.rs"
+
 [dependencies]
 anyhow = "1.0"
 crossbeam-channel = "0.4"
diff --git a/crates/ra_lsp_server/build.rs b/crates/rust-analyzer/build.rs
index 05f9772c0..05f9772c0 100644
--- a/crates/ra_lsp_server/build.rs
+++ b/crates/rust-analyzer/build.rs
diff --git a/crates/ra_lsp_server/src/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 3890fe13a..5ad3963a2 100644
--- a/crates/ra_lsp_server/src/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -5,7 +5,7 @@
 
 use anyhow::{bail, Result};
 use pico_args::Arguments;
-use ra_lsp_server::cli::{BenchWhat, Position, Verbosity};
+use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
 
 use std::{fmt::Write, path::PathBuf};
 
@@ -74,7 +74,7 @@ impl Args {
 ra-cli-parse
 
 USAGE:
-    ra_lsp_server parse [FLAGS]
+    rust-analyzer parse [FLAGS]
 
 FLAGS:
     -h, --help       Prints help inforamtion
@@ -94,7 +94,7 @@ FLAGS:
 ra-cli-symbols
 
 USAGE:
-    ra_lsp_server highlight [FLAGS]
+    rust-analyzer highlight [FLAGS]
 
 FLAGS:
     -h, --help    Prints help inforamtion"
@@ -113,7 +113,7 @@ FLAGS:
 ra-cli-highlight
 
 USAGE:
-    ra_lsp_server highlight [FLAGS]
+    rust-analyzer highlight [FLAGS]
 
 FLAGS:
     -h, --help       Prints help information
@@ -133,7 +133,7 @@ FLAGS:
 ra-cli-analysis-stats
 
 USAGE:
-    ra_lsp_server analysis-stats [FLAGS] [OPTIONS] [PATH]
+    rust-analyzer analysis-stats [FLAGS] [OPTIONS] [PATH]
 
 FLAGS:
     -h, --help            Prints help information
@@ -168,10 +168,10 @@ ARGS:
                 if matches.contains(["-h", "--help"]) {
                     eprintln!(
                         "\
-ra_lsp_server-analysis-bench
+rust-analyzer-analysis-bench
 
 USAGE:
-    ra_lsp_server analysis-bench [FLAGS] [OPTIONS] [PATH]
+    rust-analyzer analysis-bench [FLAGS] [OPTIONS] [PATH]
 
 FLAGS:
     -h, --help        Prints help information
@@ -207,7 +207,7 @@ ARGS:
 ra-cli
 
 USAGE:
-    ra_lsp_server <SUBCOMMAND>
+    rust-analyzer <SUBCOMMAND>
 
 FLAGS:
     -h, --help        Prints help information
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/rust-analyzer/src/bin/main.rs
index a549e5ff1..69e709a25 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -1,9 +1,11 @@
-//! `ra_lsp_server` binary
+//! Driver for rust-analyzer.
+//!
+//! Based on cli flags, either spawns an LSP server, or runs a batch analysis
 mod args;
 
 use lsp_server::Connection;
-use ra_lsp_server::{cli, from_json, show_message, Result, ServerConfig};
 use ra_prof;
+use rust_analyzer::{cli, from_json, show_message, Result, ServerConfig};
 
 use crate::args::HelpPrinted;
 
@@ -49,7 +51,7 @@ fn run_server() -> Result<()> {
     log::info!("lifecycle: server started");
 
     let (connection, io_threads) = Connection::stdio();
-    let server_capabilities = serde_json::to_value(ra_lsp_server::server_capabilities()).unwrap();
+    let server_capabilities = serde_json::to_value(rust_analyzer::server_capabilities()).unwrap();
 
     let initialize_params = connection.initialize(server_capabilities)?;
     let initialize_params =
@@ -82,7 +84,7 @@ fn run_server() -> Result<()> {
         })
         .unwrap_or_default();
 
-    ra_lsp_server::main_loop(
+    rust_analyzer::main_loop(
         workspace_roots,
         initialize_params.capabilities,
         server_config,
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index c4711076c..c4711076c 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
new file mode 100644
index 000000000..53751aafb
--- /dev/null
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -0,0 +1,118 @@
+//! See `CargoTargetSpec`
+
+use ra_ide::{FileId, RunnableKind, TestId};
+use ra_project_model::{self, ProjectWorkspace, TargetKind};
+
+use crate::{world::WorldSnapshot, Result};
+
+/// Abstract representation of Cargo target.
+///
+/// We use it to cook up the set of cli args we need to pass to Cargo to
+/// build/test/run the target.
+pub(crate) struct CargoTargetSpec {
+    pub(crate) package: String,
+    pub(crate) target: String,
+    pub(crate) target_kind: TargetKind,
+}
+
+impl CargoTargetSpec {
+    pub(crate) fn runnable_args(
+        spec: Option<CargoTargetSpec>,
+        kind: &RunnableKind,
+    ) -> Result<Vec<String>> {
+        let mut res = Vec::new();
+        match kind {
+            RunnableKind::Test { test_id } => {
+                res.push("test".to_string());
+                if let Some(spec) = spec {
+                    spec.push_to(&mut res);
+                }
+                res.push("--".to_string());
+                res.push(test_id.to_string());
+                if let TestId::Path(_) = test_id {
+                    res.push("--exact".to_string());
+                }
+                res.push("--nocapture".to_string());
+            }
+            RunnableKind::TestMod { path } => {
+                res.push("test".to_string());
+                if let Some(spec) = spec {
+                    spec.push_to(&mut res);
+                }
+                res.push("--".to_string());
+                res.push(path.to_string());
+                res.push("--nocapture".to_string());
+            }
+            RunnableKind::Bench { test_id } => {
+                res.push("bench".to_string());
+                if let Some(spec) = spec {
+                    spec.push_to(&mut res);
+                }
+                res.push("--".to_string());
+                res.push(test_id.to_string());
+                if let TestId::Path(_) = test_id {
+                    res.push("--exact".to_string());
+                }
+                res.push("--nocapture".to_string());
+            }
+            RunnableKind::Bin => {
+                res.push("run".to_string());
+                if let Some(spec) = spec {
+                    spec.push_to(&mut res);
+                }
+            }
+        }
+        Ok(res)
+    }
+
+    pub(crate) fn for_file(
+        world: &WorldSnapshot,
+        file_id: FileId,
+    ) -> Result<Option<CargoTargetSpec>> {
+        let &crate_id = match world.analysis().crate_for(file_id)?.first() {
+            Some(crate_id) => crate_id,
+            None => return Ok(None),
+        };
+        let file_id = world.analysis().crate_root(crate_id)?;
+        let path = world.file_id_to_path(file_id);
+        let res = world.workspaces.iter().find_map(|ws| match ws {
+            ProjectWorkspace::Cargo { cargo, .. } => {
+                let tgt = cargo.target_by_root(&path)?;
+                Some(CargoTargetSpec {
+                    package: tgt.package(&cargo).name(&cargo).to_string(),
+                    target: tgt.name(&cargo).to_string(),
+                    target_kind: tgt.kind(&cargo),
+                })
+            }
+            ProjectWorkspace::Json { .. } => None,
+        });
+        Ok(res)
+    }
+
+    pub(crate) fn push_to(self, buf: &mut Vec<String>) {
+        buf.push("--package".to_string());
+        buf.push(self.package);
+        match self.target_kind {
+            TargetKind::Bin => {
+                buf.push("--bin".to_string());
+                buf.push(self.target);
+            }
+            TargetKind::Test => {
+                buf.push("--test".to_string());
+                buf.push(self.target);
+            }
+            TargetKind::Bench => {
+                buf.push("--bench".to_string());
+                buf.push(self.target);
+            }
+            TargetKind::Example => {
+                buf.push("--example".to_string());
+                buf.push(self.target);
+            }
+            TargetKind::Lib => {
+                buf.push("--lib".to_string());
+            }
+            TargetKind::Other => (),
+        }
+    }
+}
diff --git a/crates/ra_lsp_server/src/cli.rs b/crates/rust-analyzer/src/cli.rs
index 3c7b8e250..c9738d101 100644
--- a/crates/ra_lsp_server/src/cli.rs
+++ b/crates/rust-analyzer/src/cli.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Various batch processing tasks, intended primarily for debugging.
 
 mod load_cargo;
 mod analysis_stats;
diff --git a/crates/ra_lsp_server/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index e00f81073..91855e592 100644
--- a/crates/ra_lsp_server/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Benchmark operations like highlighting or goto definition.
 
 use std::{
     path::{Path, PathBuf},
diff --git a/crates/ra_lsp_server/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index c27fabe3c..99ab6e443 100644
--- a/crates/ra_lsp_server/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! Fully type-check project and print various stats, like the number of type
+//! errors.
 
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
 
diff --git a/crates/ra_lsp_server/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index bb3e1513b..8cd08ecb6 100644
--- a/crates/ra_lsp_server/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -1,18 +1,18 @@
-//! FIXME: write short doc here
+//! Loads a Cargo project into a static instance of analysis, without support
+//! for incorporating changes.
 
-use std::{collections::HashSet, path::Path};
+use std::path::Path;
 
+use anyhow::Result;
 use crossbeam_channel::{unbounded, Receiver};
 use ra_db::{CrateGraph, FileId, SourceRootId};
 use ra_ide::{AnalysisChange, AnalysisHost, FeatureFlags};
 use ra_project_model::{get_rustc_cfg_options, PackageRoot, ProjectWorkspace};
 use ra_vfs::{RootEntry, Vfs, VfsChange, VfsTask, Watch};
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::vfs_glob::RustPackageFilterBuilder;
 
-use anyhow::Result;
-
 fn vfs_file_to_id(f: ra_vfs::VfsFile) -> FileId {
     FileId(f.0)
 }
@@ -20,7 +20,9 @@ fn vfs_root_to_id(r: ra_vfs::VfsRoot) -> SourceRootId {
     SourceRootId(r.0)
 }
 
-pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId, PackageRoot>)> {
+pub(crate) fn load_cargo(
+    root: &Path,
+) -> Result<(AnalysisHost, FxHashMap<SourceRootId, PackageRoot>)> {
     let root = std::env::current_dir()?.join(root);
     let ws = ProjectWorkspace::discover(root.as_ref(), &Default::default())?;
     let project_roots = ws.to_roots();
@@ -74,7 +76,7 @@ pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId,
     Ok((host, source_roots))
 }
 
-pub fn load(
+pub(crate) fn load(
     source_roots: &FxHashMap<SourceRootId, PackageRoot>,
     crate_graph: CrateGraph,
     vfs: &mut Vfs,
@@ -86,7 +88,7 @@ pub fn load(
     analysis_change.set_crate_graph(crate_graph);
 
     // wait until Vfs has loaded all roots
-    let mut roots_loaded = HashSet::new();
+    let mut roots_loaded = FxHashSet::default();
     for task in receiver {
         vfs.handle_task(task);
         let mut done = false;
diff --git a/crates/ra_lsp_server/src/cli/progress_report.rs b/crates/rust-analyzer/src/cli/progress_report.rs
index 31867a1e9..31867a1e9 100644
--- a/crates/ra_lsp_server/src/cli/progress_report.rs
+++ b/crates/rust-analyzer/src/cli/progress_report.rs
diff --git a/crates/ra_lsp_server/src/config.rs b/crates/rust-analyzer/src/config.rs
index 3314269ec..3314269ec 100644
--- a/crates/ra_lsp_server/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index 8af74b211..90ef74056 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -1,4 +1,5 @@
-//! Convenience module responsible for translating between rust-analyzer's types and LSP types.
+//! Convenience module responsible for translating between rust-analyzer's types
+//! and LSP types.
 
 use lsp_types::{
     self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
diff --git a/crates/ra_lsp_server/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index ea08bce24..e7924f0a3 100644
--- a/crates/ra_lsp_server/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -1,7 +1,9 @@
 //! Book keeping for keeping diagnostics easily in sync with the client.
+
+use std::{collections::HashMap, sync::Arc};
+
 use lsp_types::{CodeActionOrCommand, Diagnostic, Range};
 use ra_ide::FileId;
-use std::{collections::HashMap, sync::Arc};
 
 pub type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
 
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 958c70fe5..0dae30e46 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -1,10 +1,13 @@
 //! Implementation of the LSP for rust-analyzer.
 //!
-//! This crate takes Rust-specific analysis results from ra_ide and
-//! translates into LSP types.
+//! This crate takes Rust-specific analysis results from ra_ide and translates
+//! into LSP types.
 //!
 //! It also is the root of all state. `world` module defines the bulk of the
 //! state, and `main_loop` module defines the rules for modifying it.
+//!
+//! The `cli` submodule implements some batch-processing analysis, primarily as
+//! a debugging aid.
 #![recursion_limit = "512"]
 
 pub mod cli;
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 944074118..dc16a234d 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -1,5 +1,5 @@
-//! The main loop of `ra_lsp_server` responsible for dispatching LSP requests/replies and
-//! notifications back to the client.
+//! The main loop of `rust-analyzer` responsible for dispatching LSP
+//! requests/replies and notifications back to the client.
 
 mod handlers;
 mod subscriptions;
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index ae51141cb..bb7bab372 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -1,5 +1,6 @@
-//! This module is responsible for implementing handlers for Lanuage Server Protocol.
-//! The majority of requests are fulfilled by calling into the `ra_ide` crate.
+//! This module is responsible for implementing handlers for Language Server
+//! Protocol. The majority of requests are fulfilled by calling into the
+//! `ra_ide` crate.
 
 use std::{
     collections::hash_map::Entry,
@@ -29,7 +30,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::to_value;
 
 use crate::{
-    cargo_target_spec::{runnable_args, CargoTargetSpec},
+    cargo_target_spec::CargoTargetSpec,
     conv::{
         to_call_hierarchy_item, to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith,
         TryConvWithToVec,
@@ -921,7 +922,8 @@ fn to_lsp_runnable(
     file_id: FileId,
     runnable: Runnable,
 ) -> Result<req::Runnable> {
-    let args = runnable_args(world, file_id, &runnable.kind)?;
+    let spec = CargoTargetSpec::for_file(world, file_id)?;
+    let args = CargoTargetSpec::runnable_args(spec, &runnable.kind)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let label = match &runnable.kind {
         RunnableKind::Test { test_id } => format!("test {}", test_id),
diff --git a/crates/ra_lsp_server/src/main_loop/pending_requests.rs b/crates/rust-analyzer/src/main_loop/pending_requests.rs
index 2d2213464..73b33e419 100644
--- a/crates/ra_lsp_server/src/main_loop/pending_requests.rs
+++ b/crates/rust-analyzer/src/main_loop/pending_requests.rs
@@ -1,4 +1,4 @@
-//! Datastructures that keep track of inflight requests.
+//! Data structures that keep track of inflight requests.
 
 use std::time::{Duration, Instant};
 
diff --git a/crates/ra_lsp_server/src/main_loop/subscriptions.rs b/crates/rust-analyzer/src/main_loop/subscriptions.rs
index b0bae90f5..bee6437cf 100644
--- a/crates/ra_lsp_server/src/main_loop/subscriptions.rs
+++ b/crates/rust-analyzer/src/main_loop/subscriptions.rs
@@ -1,4 +1,5 @@
-//! Keeps track of file subscriptions.
+//! Keeps track of file subscriptions -- the set of currently opened files for
+//! which we want to publish diagnostics, syntax highlighting, etc.
 
 use ra_ide::FileId;
 use rustc_hash::FxHashSet;
diff --git a/crates/ra_lsp_server/src/markdown.rs b/crates/rust-analyzer/src/markdown.rs
index 76bef45cc..76bef45cc 100644
--- a/crates/ra_lsp_server/src/markdown.rs
+++ b/crates/rust-analyzer/src/markdown.rs
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/rust-analyzer/src/req.rs
index 7ff7f60b3..7ff7f60b3 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
diff --git a/crates/ra_lsp_server/src/vfs_glob.rs b/crates/rust-analyzer/src/vfs_glob.rs
index 12401d75a..91b33f94e 100644
--- a/crates/ra_lsp_server/src/vfs_glob.rs
+++ b/crates/rust-analyzer/src/vfs_glob.rs
@@ -1,4 +1,4 @@
-//! `ra_vfs_glob` crate implements exclusion rules for vfs.
+//! Exclusion rules for vfs.
 //!
 //! By default, we include only `.rs` files, and skip some know offenders like
 //! `/target` or `/node_modules` altogether.
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/rust-analyzer/src/world.rs
index 71c95d4af..96efab844 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -1,5 +1,5 @@
-//! The context or environment in which the language server functions.
-//! In our server implementation this is know as the `WorldState`.
+//! The context or environment in which the language server functions. In our
+//! server implementation this is know as the `WorldState`.
 //!
 //! Each tick provides an immutable snapshot of the state as `WorldSnapshot`.
 
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs
index 9ca31cbcc..3af63d9cf 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/main.rs
@@ -7,7 +7,7 @@ use lsp_types::{
     PartialResultParams, Position, Range, TextDocumentItem, TextDocumentPositionParams,
     WorkDoneProgressParams,
 };
-use ra_lsp_server::req::{
+use rust_analyzer::req::{
     CodeActionParams, CodeActionRequest, Completion, CompletionParams, DidOpenTextDocument,
     Formatting, OnEnter, Runnables, RunnablesParams,
 };
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/rust-analyzer/tests/heavy_tests/support.rs
index d5ea52fa9..5b90b3218 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/support.rs
@@ -19,7 +19,7 @@ use serde_json::{to_string_pretty, Value};
 use tempfile::TempDir;
 use test_utils::{find_mismatch, parse_fixture};
 
-use ra_lsp_server::{main_loop, req, ServerConfig};
+use rust_analyzer::{main_loop, req, ServerConfig};
 
 pub struct Project<'a> {
     fixture: &'a str,