81 files changed, 3051 insertions, 2433 deletions
diff --git a/Cargo.lock b/Cargo.lock
index e724c1a76..b63b5ae13 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,7 +10,7 @@ dependencies = [
 [[package]]
 name = "anyhow"
-version = "1.0.25"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
@@ -66,6 +66,11 @@ dependencies = [
 ]
 [[package]]
+name = "base64"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
 name = "bit-set"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -232,7 +237,7 @@ dependencies = [
 "crossbeam-channel 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-epoch 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-queue 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -268,9 +273,10 @@ dependencies = [
 [[package]]
 name = "crossbeam-queue"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
+ "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -620,9 +626,10 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.66.0"
+version = "0.67.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
+ "base64 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.104 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -892,6 +899,20 @@ dependencies = [
 ]
 [[package]]
+name = "ra_cargo_watch"
+version = "0.1.0"
+dependencies = [
+ "cargo_metadata 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-channel 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "insta 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "jod-thread 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lsp-types 0.67.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
 name = "ra_cfg"
 version = "0.1.0"
 dependencies = [
@@ -1034,7 +1055,7 @@ dependencies = [
 "ra_syntax 0.1.0",
 "ra_text_edit 0.1.0",
 "rand 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rayon 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rayon 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "superslice 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "test_utils 0.1.0",
@@ -1050,8 +1071,9 @@ dependencies = [
 "jod-thread 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "lsp-server 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lsp-types 0.66.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lsp-types 0.67.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_cargo_watch 0.1.0",
 "ra_ide 0.1.0",
 "ra_prof 0.1.0",
 "ra_project_model 0.1.0",
@@ -1314,21 +1336,21 @@ dependencies = [
 [[package]]
 name = "rayon"
-version = "1.2.1"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "crossbeam-deque 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "rayon-core 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rayon-core 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "rayon-core"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "crossbeam-deque 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "crossbeam-queue 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.11.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1746,7 +1768,7 @@ dependencies = [
 name = "xtask"
 version = "0.1.0"
 dependencies = [
- "anyhow 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
+ "anyhow 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "pico-args 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1765,7 +1787,7 @@ dependencies = [
 [metadata]
 "checksum aho-corasick 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "58fb5e95d83b38284460a5fda7d6470aa0b8844d283a0b614b8535e880800d2d"
-"checksum anyhow 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "9267dff192e68f3399525901e709a48c1d3982c9c072fa32f2127a0cb0babf14"
+"checksum anyhow 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "7825f6833612eb2414095684fcf6c635becf3ce97fe48cf6421321e93bfbd53c"
 "checksum anymap 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "33954243bd79057c2de7338850b85983a44588021f8a5fee574a8888c6de4344"
 "checksum arrayvec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
 "checksum atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1803c647a3ec87095e7ae7acfca019e98de5ec9a7d01343f611cf3152ed71a90"
@@ -1773,6 +1795,7 @@ dependencies = [
 "checksum backtrace 0.3.40 (registry+https://github.com/rust-lang/crates.io-index)" = "924c76597f0d9ca25d762c25a4d369d51267536465dc5064bdf0eb073ed477ea"
 "checksum backtrace-sys 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491"
 "checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
+"checksum base64 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
 "checksum bit-set 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e84c238982c4b1e1ee668d136c510c67a13465279c0cb367ea6baf6310620a80"
 "checksum bit-vec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f59bbe95d4e52a6398ec21238d31577f2b28a9d86807f06ca59d191d8440d0bb"
 "checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
@@ -1795,7 +1818,7 @@ dependencies = [
 "checksum crossbeam-channel 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "acec9a3b0b3559f15aee4f90746c4e5e293b701c0f7d3925d24e01645267b68c"
 "checksum crossbeam-deque 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c3aa945d63861bfe624b55d153a39684da1e8c0bc8fba932f7ee3a3c16cea3ca"
 "checksum crossbeam-epoch 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5064ebdbf05ce3cb95e45c8b086f72263f4166b29b97f6baff7ef7fe047b55ac"
-"checksum crossbeam-queue 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dfd6515864a82d2f877b42813d4553292c6659498c9a2aa31bab5a15243c2700"
+"checksum crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db"
 "checksum crossbeam-utils 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ce446db02cdc3165b94ae73111e570793400d0794e46125cc4056c81cbb039f4"
 "checksum difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
 "checksum drop_bomb 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "69b26e475fd29098530e709294e94e661974c851aed42512793f120fed4e199f"
@@ -1842,7 +1865,7 @@ dependencies = [
 "checksum lock_api 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e57b3997725d2b60dbec1297f6c2e2957cc383db1cebd6be812163f969c7d586"
 "checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
 "checksum lsp-server 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0ba36405bd742139ab79c246ca5adb7fde2fe1a0f495e2c8e2f607b607dedb12"
-"checksum lsp-types 0.66.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a2dddfe2791cbf4b5eff5a581e45becf47a24b128a62de80e7cc135bf50064"
+"checksum lsp-types 0.67.1 (registry+https://github.com/rust-lang/crates.io-index)" = "aea9639ebf210bd5de66931cbdb2d4a8bcc1fa1e5b2dece7daa6b387ab42e803"
 "checksum matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
 "checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
 "checksum memoffset 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "75189eb85871ea5c2e2c15abbdd541185f63b408415e5051f5cac122d8c774b9"
@@ -1884,8 +1907,8 @@ dependencies = [
 "checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
 "checksum rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
 "checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
-"checksum rayon 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "43739f8831493b276363637423d3622d4bd6394ab6f0a9c4a552e208aeb7fddd"
+"checksum rayon 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "db6ce3297f9c85e16621bb8cca38a06779ffc31bb8184e1be4bed2be4678a098"
-"checksum rayon-core 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f8bf17de6f23b05473c437eb958b9c850bfc8af0961fe17b4cc92d5a627b4791"
+"checksum rayon-core 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "08a89b46efaf957e52b18062fb2f4660f8b8a4dde1807ca002690868ef2c85a9"
 "checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
 "checksum redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)" = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
 "checksum regex 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dc220bd33bdce8f093101afe22a037b8eb0e5af33592e6a9caafff0d4cb81cbd"
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 993aebc47..28152f724 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -46,7 +46,7 @@ pub(crate) enum Assist {
 ///
 /// Note, however, that we don't actually use such two-phase logic at the
 /// moment, because the LSP API is pretty awkward in this place, and it's much
-/// easier to just compute the edit eagerly :-)#[derive(Debug, Clone)]
+/// easier to just compute the edit eagerly :-)
 #[derive(Debug)]
 pub(crate) struct AssistCtx<'a, DB> {
    pub(crate) db: &'a DB,
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index eeb4ff39f..2c602a79e 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -74,6 +74,24 @@ mod tests {
    }
    #[test]
+    fn add_explicit_type_works_for_macro_call() {
+        check_assist(
+            add_explicit_type,
+            "macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
+            "macro_rules! v { () => {0u64} } fn f() { let a<|>: u64 = v!(); }",
+        );
+    }
+    #[test]
+    fn add_explicit_type_works_for_macro_call_recursive() {
+        check_assist(
+            add_explicit_type,
+            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }",
+            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|>: u64 = v!(); }",
+        );
+    }
+    #[test]
    fn add_explicit_type_not_applicable_if_ty_not_inferred() {
        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|> = None; }");
    }
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/assists/add_missing_impl_members.rs
index cef669cb5..bc49e71fe 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
 use hir::{db::HirDatabase, HasSource};
 use ra_syntax::{
    ast::{self, edit, make, AstNode, NameOwner},
@@ -17,26 +19,26 @@ enum AddMissingImplMembersMode {
 // Adds scaffold for required impl members.
 //
 // ```
-// trait T {
+// trait Trait<T> {
 //     Type X;
-//     fn foo(&self);
+//     fn foo(&self) -> T;
 //     fn bar(&self) {}
 // }
 //
-// impl T for () {<|>
+// impl Trait<u32> for () {<|>
 //
 // }
 // ```
 // ->
 // ```
-// trait T {
+// trait Trait<T> {
 //     Type X;
-//     fn foo(&self);
+//     fn foo(&self) -> T;
 //     fn bar(&self) {}
 // }
 //
-// impl T for () {
+// impl Trait<u32> for () {
-//     fn foo(&self) { unimplemented!() }
+//     fn foo(&self) -> u32 { unimplemented!() }
 //
 // }
 // ```
@@ -54,13 +56,13 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Opti
 // Adds scaffold for overriding default impl members.
 //
 // ```
-// trait T {
+// trait Trait {
 //     Type X;
 //     fn foo(&self);
 //     fn bar(&self) {}
 // }
 //
-// impl T for () {
+// impl Trait for () {
 //     Type X = ();
 //     fn foo(&self) {}<|>
 //
@@ -68,13 +70,13 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Opti
 // ```
 // ->
 // ```
-// trait T {
+// trait Trait {
 //     Type X;
 //     fn foo(&self);
 //     fn bar(&self) {}
 // }
 //
-// impl T for () {
+// impl Trait for () {
 //     Type X = ();
 //     fn foo(&self) {}
 //     fn bar(&self) {}
@@ -99,7 +101,7 @@ fn add_missing_impl_members_inner(
    let impl_node = ctx.find_node_at_offset::<ast::ImplBlock>()?;
    let impl_item_list = impl_node.item_list()?;
-    let trait_def = {
+    let (trait_, trait_def) = {
        let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
        resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
@@ -132,10 +134,25 @@ fn add_missing_impl_members_inner(
        return None;
    }
+    let file_id = ctx.frange.file_id;
+    let db = ctx.db;
    ctx.add_assist(AssistId(assist_id), label, |edit| {
        let n_existing_items = impl_item_list.impl_items().count();
+        let substs = get_syntactic_substs(impl_node).unwrap_or_default();
+        let generic_def: hir::GenericDef = trait_.into();
+        let substs_by_param: HashMap<_, _> = generic_def
+            .params(db)
+            .into_iter()
+            // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
+            .skip(1)
+            .zip(substs.into_iter())
+            .collect();
        let items = missing_items
            .into_iter()
+            .map(|it| {
+                substitute_type_params(db, hir::InFile::new(file_id.into(), it), &substs_by_param)
+            })
            .map(|it| match it {
                ast::ImplItem::FnDef(def) => ast::ImplItem::FnDef(add_body(def)),
                _ => it,
@@ -160,13 +177,63 @@ fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
    }
 }
+// FIXME: It would probably be nicer if we could get this via HIR (i.e. get the
+// trait ref, and then go from the types in the substs back to the syntax)
+// FIXME: This should be a general utility (not even just for assists)
+fn get_syntactic_substs(impl_block: ast::ImplBlock) -> Option<Vec<ast::TypeRef>> {
+    let target_trait = impl_block.target_trait()?;
+    let path_type = match target_trait {
+        ast::TypeRef::PathType(path) => path,
+        _ => return None,
+    };
+    let type_arg_list = path_type.path()?.segment()?.type_arg_list()?;
+    let mut result = Vec::new();
+    for type_arg in type_arg_list.type_args() {
+        let type_arg: ast::TypeArg = type_arg;
+        result.push(type_arg.type_ref()?);
+    }
+    Some(result)
+}
+// FIXME: This should be a general utility (not even just for assists)
+fn substitute_type_params<N: AstNode>(
+    db: &impl HirDatabase,
+    node: hir::InFile<N>,
+    substs: &HashMap<hir::TypeParam, ast::TypeRef>,
+) -> N {
+    let type_param_replacements = node
+        .value
+        .syntax()
+        .descendants()
+        .filter_map(ast::TypeRef::cast)
+        .filter_map(|n| {
+            let path = match &n {
+                ast::TypeRef::PathType(path_type) => path_type.path()?,
+                _ => return None,
+            };
+            let analyzer = hir::SourceAnalyzer::new(db, node.with_value(n.syntax()), None);
+            let resolution = analyzer.resolve_path(db, &path)?;
+            match resolution {
+                hir::PathResolution::TypeParam(tp) => Some((n, substs.get(&tp)?.clone())),
+                _ => None,
+            }
+        })
+        .collect::<Vec<_>>();
+    if type_param_replacements.is_empty() {
+        node.value
+    } else {
+        edit::replace_descendants(&node.value, type_param_replacements.into_iter())
+    }
+}
 /// Given an `ast::ImplBlock`, resolves the target trait (the one being
 /// implemented) to a `ast::TraitDef`.
 fn resolve_target_trait_def(
    db: &impl HirDatabase,
    analyzer: &hir::SourceAnalyzer,
    impl_block: &ast::ImplBlock,
-) -> Option<ast::TraitDef> {
+) -> Option<(hir::Trait, ast::TraitDef)> {
    let ast_path = impl_block
        .target_trait()
        .map(|it| it.syntax().clone())
@@ -174,7 +241,9 @@ fn resolve_target_trait_def(
        .path()?;
    match analyzer.resolve_path(db, &ast_path) {
-        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).value),
+        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => {
+            Some((def, def.source(db).value))
+        }
        _ => None,
    }
 }
@@ -281,6 +350,40 @@ impl Foo for S {
    }
    #[test]
+    fn fill_in_type_params_1() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl Foo<u32> for S { <|> }",
+            "
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl Foo<u32> for S {
+    <|>fn foo(&self, t: u32) -> &u32 { unimplemented!() }
+}",
+        );
+    }
+    #[test]
+    fn fill_in_type_params_2() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl<U> Foo<U> for S { <|> }",
+            "
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl<U> Foo<U> for S {
+    <|>fn foo(&self, t: U) -> &U { unimplemented!() }
+}",
+        );
+    }
+    #[test]
    fn test_cursor_after_empty_impl_block() {
        check_assist(
            add_missing_impl_members,
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 4586eeb59..7d84dc8fb 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -101,26 +101,26 @@ fn doctest_add_impl_default_members() {
    check(
        "add_impl_default_members",
        r#####"
-trait T {
+trait Trait {
    Type X;
    fn foo(&self);
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait for () {
    Type X = ();
    fn foo(&self) {}<|>
 }
 "#####,
        r#####"
-trait T {
+trait Trait {
    Type X;
    fn foo(&self);
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait for () {
    Type X = ();
    fn foo(&self) {}
    fn bar(&self) {}
@@ -135,25 +135,25 @@ fn doctest_add_impl_missing_members() {
    check(
        "add_impl_missing_members",
        r#####"
-trait T {
+trait Trait<T> {
    Type X;
-    fn foo(&self);
+    fn foo(&self) -> T;
    fn bar(&self) {}
 }
-impl T for () {<|>
+impl Trait<u32> for () {<|>
 }
 "#####,
        r#####"
-trait T {
+trait Trait<T> {
    Type X;
-    fn foo(&self);
+    fn foo(&self) -> T;
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait<u32> for () {
-    fn foo(&self) { unimplemented!() }
+    fn foo(&self) -> u32 { unimplemented!() }
 }
 "#####,
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
new file mode 100644
index 000000000..bcc4648ff
--- /dev/null
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+edition = "2018"
+name = "ra_cargo_watch"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+[dependencies]
+crossbeam-channel = "0.4"
+lsp-types = { version = "0.67.0", features = ["proposed"] }
+log = "0.4.3"
+cargo_metadata = "0.9.1"
+jod-thread = "0.1.0"
+parking_lot = "0.10.0"
+[dev-dependencies]
+insta = "0.12.0"
+serde_json = "1.0"
+\ No newline at end of file
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_cargo_watch/src/conv.rs
new file mode 100644
index 000000000..3bd4bf7a5
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv.rs
@@ -0,0 +1,280 @@
+//! This module provides the functionality needed to convert diagnostics from
+//! `cargo check` json format to the LSP diagnostic format.
+use cargo_metadata::diagnostic::{
+    Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
+    DiagnosticSpanMacroExpansion,
+};
+use lsp_types::{
+    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag, Location,
+    NumberOrString, Position, Range, Url,
+};
+use std::{fmt::Write, path::PathBuf};
+#[cfg(test)]
+mod test;
+/// Converts a Rust level string to a LSP severity
+fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
+    match val {
+        DiagnosticLevel::Ice => Some(DiagnosticSeverity::Error),
+        DiagnosticLevel::Error => Some(DiagnosticSeverity::Error),
+        DiagnosticLevel::Warning => Some(DiagnosticSeverity::Warning),
+        DiagnosticLevel::Note => Some(DiagnosticSeverity::Information),
+        DiagnosticLevel::Help => Some(DiagnosticSeverity::Hint),
+        DiagnosticLevel::Unknown => None,
+    }
+}
+/// Check whether a file name is from macro invocation
+fn is_from_macro(file_name: &str) -> bool {
+    file_name.starts_with('<') && file_name.ends_with('>')
+}
+/// Converts a Rust macro span to a LSP location recursively
+fn map_macro_span_to_location(
+    span_macro: &DiagnosticSpanMacroExpansion,
+    workspace_root: &PathBuf,
+) -> Option<Location> {
+    if !is_from_macro(&span_macro.span.file_name) {
+        return Some(map_span_to_location(&span_macro.span, workspace_root));
+    }
+    if let Some(expansion) = &span_macro.span.expansion {
+        return map_macro_span_to_location(&expansion, workspace_root);
+    }
+    None
+}
+/// Converts a Rust span to a LSP location
+fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
+    if is_from_macro(&span.file_name) && span.expansion.is_some() {
+        let expansion = span.expansion.as_ref().unwrap();
+        if let Some(macro_range) = map_macro_span_to_location(&expansion, workspace_root) {
+            return macro_range;
+        }
+    }
+    let mut file_name = workspace_root.clone();
+    file_name.push(&span.file_name);
+    let uri = Url::from_file_path(file_name).unwrap();
+    let range = Range::new(
+        Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
+        Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
+    );
+    Location { uri, range }
+}
+/// Converts a secondary Rust span to a LSP related information
+///
+/// If the span is unlabelled this will return `None`.
+fn map_secondary_span_to_related(
+    span: &DiagnosticSpan,
+    workspace_root: &PathBuf,
+) -> Option<DiagnosticRelatedInformation> {
+    if let Some(label) = &span.label {
+        let location = map_span_to_location(span, workspace_root);
+        Some(DiagnosticRelatedInformation { location, message: label.clone() })
+    } else {
+        // Nothing to label this with
+        None
+    }
+}
+/// Determines if diagnostic is related to unused code
+fn is_unused_or_unnecessary(rd: &RustDiagnostic) -> bool {
+    if let Some(code) = &rd.code {
+        match code.code.as_str() {
+            "dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"
+            | "unused_imports" | "unused_macros" | "unused_variables" => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+/// Determines if diagnostic is related to deprecated code
+fn is_deprecated(rd: &RustDiagnostic) -> bool {
+    if let Some(code) = &rd.code {
+        match code.code.as_str() {
+            "deprecated" => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+#[derive(Debug)]
+pub struct SuggestedFix {
+    pub title: String,
+    pub location: Location,
+    pub replacement: String,
+    pub applicability: Applicability,
+    pub diagnostics: Vec<Diagnostic>,
+}
+impl std::cmp::PartialEq<SuggestedFix> for SuggestedFix {
+    fn eq(&self, other: &SuggestedFix) -> bool {
+        if self.title == other.title
+            && self.location == other.location
+            && self.replacement == other.replacement
+        {
+            // Applicability doesn't impl PartialEq...
+            match (&self.applicability, &other.applicability) {
+                (Applicability::MachineApplicable, Applicability::MachineApplicable) => true,
+                (Applicability::HasPlaceholders, Applicability::HasPlaceholders) => true,
+                (Applicability::MaybeIncorrect, Applicability::MaybeIncorrect) => true,
+                (Applicability::Unspecified, Applicability::Unspecified) => true,
+                _ => false,
+            }
+        } else {
+            false
+        }
+    }
+}
+enum MappedRustChildDiagnostic {
+    Related(DiagnosticRelatedInformation),
+    SuggestedFix(SuggestedFix),
+    MessageLine(String),
+}
+fn map_rust_child_diagnostic(
+    rd: &RustDiagnostic,
+    workspace_root: &PathBuf,
+) -> MappedRustChildDiagnostic {
+    let span: &DiagnosticSpan = match rd.spans.iter().find(|s| s.is_primary) {
+        Some(span) => span,
+        None => {
+            // `rustc` uses these spanless children as a way to print multi-line
+            // messages
+            return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
+        }
+    };
+    // If we have a primary span use its location, otherwise use the parent
+    let location = map_span_to_location(&span, workspace_root);
+    if let Some(suggested_replacement) = &span.suggested_replacement {
+        // Include our replacement in the title unless it's empty
+        let title = if !suggested_replacement.is_empty() {
+            format!("{}: '{}'", rd.message, suggested_replacement)
+        } else {
+            rd.message.clone()
+        };
+        MappedRustChildDiagnostic::SuggestedFix(SuggestedFix {
+            title,
+            location,
+            replacement: suggested_replacement.clone(),
+            applicability: span.suggestion_applicability.clone().unwrap_or(Applicability::Unknown),
+            diagnostics: vec![],
+        })
+    } else {
+        MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
+            location,
+            message: rd.message.clone(),
+        })
+    }
+}
+#[derive(Debug)]
+pub(crate) struct MappedRustDiagnostic {
+    pub location: Location,
+    pub diagnostic: Diagnostic,
+    pub suggested_fixes: Vec<SuggestedFix>,
+}
+/// Converts a Rust root diagnostic to LSP form
+///
+/// This flattens the Rust diagnostic by:
+///
+/// 1. Creating a LSP diagnostic with the root message and primary span.
+/// 2. Adding any labelled secondary spans to `relatedInformation`
+/// 3. Categorising child diagnostics as either `SuggestedFix`es,
+///    `relatedInformation` or additional message lines.
+///
+/// If the diagnostic has no primary span this will return `None`
+pub(crate) fn map_rust_diagnostic_to_lsp(
+    rd: &RustDiagnostic,
+    workspace_root: &PathBuf,
+) -> Option<MappedRustDiagnostic> {
+    let primary_span = rd.spans.iter().find(|s| s.is_primary)?;
+    let location = map_span_to_location(&primary_span, workspace_root);
+    let severity = map_level_to_severity(rd.level);
+    let mut primary_span_label = primary_span.label.as_ref();
+    let mut source = String::from("rustc");
+    let mut code = rd.code.as_ref().map(|c| c.code.clone());
+    if let Some(code_val) = &code {
+        // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
+        let scoped_code: Vec<&str> = code_val.split("::").collect();
+        if scoped_code.len() == 2 {
+            source = String::from(scoped_code[0]);
+            code = Some(String::from(scoped_code[1]));
+        }
+    }
+    let mut related_information = vec![];
+    let mut tags = vec![];
+    for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
+        let related = map_secondary_span_to_related(secondary_span, workspace_root);
+        if let Some(related) = related {
+            related_information.push(related);
+        }
+    }
+    let mut suggested_fixes = vec![];
+    let mut message = rd.message.clone();
+    for child in &rd.children {
+        let child = map_rust_child_diagnostic(&child, workspace_root);
+        match child {
+            MappedRustChildDiagnostic::Related(related) => related_information.push(related),
+            MappedRustChildDiagnostic::SuggestedFix(suggested_fix) => {
+                suggested_fixes.push(suggested_fix)
+            }
+            MappedRustChildDiagnostic::MessageLine(message_line) => {
+                write!(&mut message, "\n{}", message_line).unwrap();
+                // These secondary messages usually duplicate the content of the
+                // primary span label.
+                primary_span_label = None;
+            }
+        }
+    }
+    if let Some(primary_span_label) = primary_span_label {
+        write!(&mut message, "\n{}", primary_span_label).unwrap();
+    }
+    if is_unused_or_unnecessary(rd) {
+        tags.push(DiagnosticTag::Unnecessary);
+    }
+    if is_deprecated(rd) {
+        tags.push(DiagnosticTag::Deprecated);
+    }
+    let diagnostic = Diagnostic {
+        range: location.range,
+        severity,
+        code: code.map(NumberOrString::String),
+        source: Some(source),
+        message,
+        related_information: if !related_information.is_empty() {
+            Some(related_information)
+        } else {
+            None
+        },
+        tags: if !tags.is_empty() { Some(tags) } else { None },
+    };
+    Some(MappedRustDiagnostic { location, diagnostic, suggested_fixes })
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap
new file mode 100644
index 000000000..cb0920914
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_clippy_pass_by_ref.snap
@@ -0,0 +1,85 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/mir/tagset.rs",
+        range: Range {
+            start: Position {
+                line: 41,
+                character: 23,
+            },
+            end: Position {
+                line: 41,
+                character: 28,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 41,
+                character: 23,
+            },
+            end: Position {
+                line: 41,
+                character: 28,
+            },
+        },
+        severity: Some(
+            Warning,
+        ),
+        code: Some(
+            String(
+                "trivially_copy_pass_by_ref",
+            ),
+        ),
+        source: Some(
+            "clippy",
+        ),
+        message: "this argument is passed by reference, but would be more efficient if passed by value\n#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
+        related_information: Some(
+            [
+                DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: "file:///test/compiler/lib.rs",
+                        range: Range {
+                            start: Position {
+                                line: 0,
+                                character: 8,
+                            },
+                            end: Position {
+                                line: 0,
+                                character: 19,
+                            },
+                        },
+                    },
+                    message: "lint level defined here",
+                },
+            ],
+        ),
+        tags: None,
+    },
+    suggested_fixes: [
+        SuggestedFix {
+            title: "consider passing by value instead: \'self\'",
+            location: Location {
+                uri: "file:///test/compiler/mir/tagset.rs",
+                range: Range {
+                    start: Position {
+                        line: 41,
+                        character: 23,
+                    },
+                    end: Position {
+                        line: 41,
+                        character: 28,
+                    },
+                },
+            },
+            replacement: "self",
+            applicability: Unspecified,
+            diagnostics: [],
+        },
+    ],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap
new file mode 100644
index 000000000..19510ecc1
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_handles_macro_location.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/src/main.rs",
+        range: Range {
+            start: Position {
+                line: 1,
+                character: 4,
+            },
+            end: Position {
+                line: 1,
+                character: 26,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 1,
+                character: 4,
+            },
+            end: Position {
+                line: 1,
+                character: 26,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0277",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "can\'t compare `{integer}` with `&str`\nthe trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap
new file mode 100644
index 000000000..cf683e4b6
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_incompatible_type_for_trait.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/ty/list_iter.rs",
+        range: Range {
+            start: Position {
+                line: 51,
+                character: 4,
+            },
+            end: Position {
+                line: 51,
+                character: 47,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 51,
+                character: 4,
+            },
+            end: Position {
+                line: 51,
+                character: 47,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0053",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "method `next` has an incompatible type for trait\nexpected type `fn(&mut ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&\'list ty::Ref<M>>`",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap
new file mode 100644
index 000000000..8c1483c74
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_mismatched_type.snap
@@ -0,0 +1,46 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/runtime/compiler_support.rs",
+        range: Range {
+            start: Position {
+                line: 47,
+                character: 64,
+            },
+            end: Position {
+                line: 47,
+                character: 69,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 47,
+                character: 64,
+            },
+            end: Position {
+                line: 47,
+                character: 69,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0308",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "mismatched types\nexpected usize, found u32",
+        related_information: None,
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap
new file mode 100644
index 000000000..eb5a2247b
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_unused_variable.snap
@@ -0,0 +1,70 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/driver/subcommand/repl.rs",
+        range: Range {
+            start: Position {
+                line: 290,
+                character: 8,
+            },
+            end: Position {
+                line: 290,
+                character: 11,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 290,
+                character: 8,
+            },
+            end: Position {
+                line: 290,
+                character: 11,
+            },
+        },
+        severity: Some(
+            Warning,
+        ),
+        code: Some(
+            String(
+                "unused_variables",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+        related_information: None,
+        tags: Some(
+            [
+                Unnecessary,
+            ],
+        ),
+    },
+    suggested_fixes: [
+        SuggestedFix {
+            title: "consider prefixing with an underscore: \'_foo\'",
+            location: Location {
+                uri: "file:///test/driver/subcommand/repl.rs",
+                range: Range {
+                    start: Position {
+                        line: 290,
+                        character: 8,
+                    },
+                    end: Position {
+                        line: 290,
+                        character: 11,
+                    },
+                },
+            },
+            replacement: "_foo",
+            applicability: MachineApplicable,
+            diagnostics: [],
+        },
+    ],
+}
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap
new file mode 100644
index 000000000..2f4518931
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/test__snap_rustc_wrong_number_of_parameters.snap
@@ -0,0 +1,65 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+MappedRustDiagnostic {
+    location: Location {
+        uri: "file:///test/compiler/ty/select.rs",
+        range: Range {
+            start: Position {
+                line: 103,
+                character: 17,
+            },
+            end: Position {
+                line: 103,
+                character: 29,
+            },
+        },
+    },
+    diagnostic: Diagnostic {
+        range: Range {
+            start: Position {
+                line: 103,
+                character: 17,
+            },
+            end: Position {
+                line: 103,
+                character: 29,
+            },
+        },
+        severity: Some(
+            Error,
+        ),
+        code: Some(
+            String(
+                "E0061",
+            ),
+        ),
+        source: Some(
+            "rustc",
+        ),
+        message: "this function takes 2 parameters but 3 parameters were supplied\nexpected 2 parameters",
+        related_information: Some(
+            [
+                DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: "file:///test/compiler/ty/select.rs",
+                        range: Range {
+                            start: Position {
+                                line: 218,
+                                character: 4,
+                            },
+                            end: Position {
+                                line: 230,
+                                character: 5,
+                            },
+                        },
+                    },
+                    message: "defined here",
+                },
+            ],
+        ),
+        tags: None,
+    },
+    suggested_fixes: [],
+}
diff --git a/crates/ra_cargo_watch/src/conv/test.rs b/crates/ra_cargo_watch/src/conv/test.rs
new file mode 100644
index 000000000..6817245c2
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/test.rs
@@ -0,0 +1,700 @@
+//! This module contains the large and verbose snapshot tests for the
+//! conversions between `cargo check` json and LSP diagnostics.
+use crate::*;
+fn parse_diagnostic(val: &str) -> cargo_metadata::diagnostic::Diagnostic {
+    serde_json::from_str::<cargo_metadata::diagnostic::Diagnostic>(val).unwrap()
+}
+#[test]
+fn snap_rustc_incompatible_type_for_trait() {
+    let diag = parse_diagnostic(
+        r##"{
+            "message": "method `next` has an incompatible type for trait",
+            "code": {
+                "code": "E0053",
+                "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n    fn foo(x: u16);\n    fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n    // error, expected u16, found i16\n    fn foo(x: i16) { }\n\n    // error, types differ in mutability\n    fn bar(&mut self) { }\n}\n```\n"
+            },
+            "level": "error",
+            "spans": [
+                {
+                    "file_name": "compiler/ty/list_iter.rs",
+                    "byte_start": 1307,
+                    "byte_end": 1350,
+                    "line_start": 52,
+                    "line_end": 52,
+                    "column_start": 5,
+                    "column_end": 48,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    fn next(&self) -> Option<&'list ty::Ref<M>> {",
+                            "highlight_start": 5,
+                            "highlight_end": 48
+                        }
+                    ],
+                    "label": "types differ in mutability",
+                    "suggested_replacement": null,
+                    "suggestion_applicability": null,
+                    "expansion": null
+                }
+            ],
+            "children": [
+                {
+                    "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
+                    "code": null,
+                    "level": "note",
+                    "spans": [],
+                    "children": [],
+                    "rendered": null
+                }
+            ],
+            "rendered": "error[E0053]: method `next` has an incompatible type for trait\n  --> compiler/ty/list_iter.rs:52:5\n   |\n52 |     fn next(&self) -> Option<&'list ty::Ref<M>> {\n   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n   |\n   = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n              found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
+        }
+        "##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_unused_variable() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "unused variable: `foo`",
+"code": {
+    "code": "unused_variables",
+    "explanation": null
+},
+"level": "warning",
+"spans": [
+    {
+        "file_name": "driver/subcommand/repl.rs",
+        "byte_start": 9228,
+        "byte_end": 9231,
+        "line_start": 291,
+        "line_end": 291,
+        "column_start": 9,
+        "column_end": 12,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    let foo = 42;",
+                "highlight_start": 9,
+                "highlight_end": 12
+            }
+        ],
+        "label": null,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [
+    {
+        "message": "#[warn(unused_variables)] on by default",
+        "code": null,
+        "level": "note",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "consider prefixing with an underscore",
+        "code": null,
+        "level": "help",
+        "spans": [
+            {
+                "file_name": "driver/subcommand/repl.rs",
+                "byte_start": 9228,
+                "byte_end": 9231,
+                "line_start": 291,
+                "line_end": 291,
+                "column_start": 9,
+                "column_end": 12,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "    let foo = 42;",
+                        "highlight_start": 9,
+                        "highlight_end": 12
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": "_foo",
+                "suggestion_applicability": "MachineApplicable",
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    }
+],
+"rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_wrong_number_of_parameters() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "this function takes 2 parameters but 3 parameters were supplied",
+"code": {
+    "code": "E0061",
+    "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
+},
+"level": "error",
+"spans": [
+    {
+        "file_name": "compiler/ty/select.rs",
+        "byte_start": 8787,
+        "byte_end": 9241,
+        "line_start": 219,
+        "line_end": 231,
+        "column_start": 5,
+        "column_end": 6,
+        "is_primary": false,
+        "text": [
+            {
+                "text": "    pub fn add_evidence(",
+                "highlight_start": 5,
+                "highlight_end": 25
+            },
+            {
+                "text": "        &mut self,",
+                "highlight_start": 1,
+                "highlight_end": 19
+            },
+            {
+                "text": "        target_poly: &ty::Ref<ty::Poly>,",
+                "highlight_start": 1,
+                "highlight_end": 41
+            },
+            {
+                "text": "        evidence_poly: &ty::Ref<ty::Poly>,",
+                "highlight_start": 1,
+                "highlight_end": 43
+            },
+            {
+                "text": "    ) {",
+                "highlight_start": 1,
+                "highlight_end": 8
+            },
+            {
+                "text": "        match target_poly {",
+                "highlight_start": 1,
+                "highlight_end": 28
+            },
+            {
+                "text": "            ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
+                "highlight_start": 1,
+                "highlight_end": 81
+            },
+            {
+                "text": "            ty::Ref::Fixed(target_ty) => {",
+                "highlight_start": 1,
+                "highlight_end": 43
+            },
+            {
+                "text": "                let evidence_ty = evidence_poly.resolve_to_ty();",
+                "highlight_start": 1,
+                "highlight_end": 65
+            },
+            {
+                "text": "                self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
+                "highlight_start": 1,
+                "highlight_end": 76
+            },
+            {
+                "text": "            }",
+                "highlight_start": 1,
+                "highlight_end": 14
+            },
+            {
+                "text": "        }",
+                "highlight_start": 1,
+                "highlight_end": 10
+            },
+            {
+                "text": "    }",
+                "highlight_start": 1,
+                "highlight_end": 6
+            }
+        ],
+        "label": "defined here",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    },
+    {
+        "file_name": "compiler/ty/select.rs",
+        "byte_start": 4045,
+        "byte_end": 4057,
+        "line_start": 104,
+        "line_end": 104,
+        "column_start": 18,
+        "column_end": 30,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "            self.add_evidence(target_fixed, evidence_fixed, false);",
+                "highlight_start": 18,
+                "highlight_end": 30
+            }
+        ],
+        "label": "expected 2 parameters",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [],
+"rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n   --> compiler/ty/select.rs:104:18\n    |\n104 |               self.add_evidence(target_fixed, evidence_fixed, false);\n    |                    ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | /     pub fn add_evidence(\n220 | |         &mut self,\n221 | |         target_poly: &ty::Ref<ty::Poly>,\n222 | |         evidence_poly: &ty::Ref<ty::Poly>,\n...   |\n230 | |         }\n231 | |     }\n    | |_____- defined here\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_clippy_pass_by_ref() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "this argument is passed by reference, but would be more efficient if passed by value",
+"code": {
+    "code": "clippy::trivially_copy_pass_by_ref",
+    "explanation": null
+},
+"level": "warning",
+"spans": [
+    {
+        "file_name": "compiler/mir/tagset.rs",
+        "byte_start": 941,
+        "byte_end": 946,
+        "line_start": 42,
+        "line_end": 42,
+        "column_start": 24,
+        "column_end": 29,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
+                "highlight_start": 24,
+                "highlight_end": 29
+            }
+        ],
+        "label": null,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [
+    {
+        "message": "lint level defined here",
+        "code": null,
+        "level": "note",
+        "spans": [
+            {
+                "file_name": "compiler/lib.rs",
+                "byte_start": 8,
+                "byte_end": 19,
+                "line_start": 1,
+                "line_end": 1,
+                "column_start": 9,
+                "column_end": 20,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "#![warn(clippy::all)]",
+                        "highlight_start": 9,
+                        "highlight_end": 20
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
+        "code": null,
+        "level": "note",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
+        "code": null,
+        "level": "help",
+        "spans": [],
+        "children": [],
+        "rendered": null
+    },
+    {
+        "message": "consider passing by value instead",
+        "code": null,
+        "level": "help",
+        "spans": [
+            {
+                "file_name": "compiler/mir/tagset.rs",
+                "byte_start": 941,
+                "byte_end": 946,
+                "line_start": 42,
+                "line_end": 42,
+                "column_start": 24,
+                "column_end": 29,
+                "is_primary": true,
+                "text": [
+                    {
+                        "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
+                        "highlight_start": 24,
+                        "highlight_end": 29
+                    }
+                ],
+                "label": null,
+                "suggested_replacement": "self",
+                "suggestion_applicability": "Unspecified",
+                "expansion": null
+            }
+        ],
+        "children": [],
+        "rendered": null
+    }
+],
+"rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n  --> compiler/mir/tagset.rs:42:24\n   |\n42 |     pub fn is_disjoint(&self, other: Self) -> bool {\n   |                        ^^^^^ help: consider passing by value instead: `self`\n   |\nnote: lint level defined here\n  --> compiler/lib.rs:1:9\n   |\n1  | #![warn(clippy::all)]\n   |         ^^^^^^^^^^^\n   = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_rustc_mismatched_type() {
+    let diag = parse_diagnostic(
+        r##"{
+"message": "mismatched types",
+"code": {
+    "code": "E0308",
+    "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n//     ~~~   ~~~~~~~~~~~~~~~~~~~~\n//      |             |\n//      |    initializing expression;\n//      |    compiler infers type `&str`\n//      |\n//    type `i32` assigned to variable `x`\n```\n"
+},
+"level": "error",
+"spans": [
+    {
+        "file_name": "runtime/compiler_support.rs",
+        "byte_start": 1589,
+        "byte_end": 1594,
+        "line_start": 48,
+        "line_end": 48,
+        "column_start": 65,
+        "column_end": 70,
+        "is_primary": true,
+        "text": [
+            {
+                "text": "    let layout = alloc::Layout::from_size_align_unchecked(size, align);",
+                "highlight_start": 65,
+                "highlight_end": 70
+            }
+        ],
+        "label": "expected usize, found u32",
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "expansion": null
+    }
+],
+"children": [],
+"rendered": "error[E0308]: mismatched types\n  --> runtime/compiler_support.rs:48:65\n   |\n48 |     let layout = alloc::Layout::from_size_align_unchecked(size, align);\n   |                                                                 ^^^^^ expected usize, found u32\n\n"
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
+#[test]
+fn snap_handles_macro_location() {
+    let diag = parse_diagnostic(
+        r##"{
+"rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n  |\n2 |     assert_eq!(1, \"love\");\n  |     ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n  |\n  = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
+"children": [
+    {
+        "children": [],
+        "code": null,
+        "level": "help",
+        "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
+        "rendered": null,
+        "spans": []
+    }
+],
+"code": {
+    "code": "E0277",
+    "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n    fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n    foo.bar();\n}\n\nfn main() {\n    // we now call the method with the i32 type, which doesn't implement\n    // the Foo trait\n    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n    fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n    foo.bar(); // we can now use this method since i32 implements the\n               // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n    fn bar(&self) {}\n}\n\nfn main() {\n    some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n    println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n                           //        implemented for the type `T`\n}\n\nfn main() {\n    // We now call the method with the i32 type,\n    // which *does* implement the Debug trait.\n    some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n    println!(\"{:?}\", foo);\n}\n\nfn main() {\n    // Calling the method is still fine, as i32 implements Debug.\n    some_func(5i32);\n\n    // This would fail to compile now:\n    // struct WithoutDebug;\n    // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
+},
+"level": "error",
+"message": "can't compare `{integer}` with `&str`",
+"spans": [
+    {
+        "byte_end": 155,
+        "byte_start": 153,
+        "column_end": 33,
+        "column_start": 31,
+        "expansion": {
+            "def_site_span": {
+                "byte_end": 940,
+                "byte_start": 0,
+                "column_end": 6,
+                "column_start": 1,
+                "expansion": null,
+                "file_name": "<::core::macros::assert_eq macros>",
+                "is_primary": false,
+                "label": null,
+                "line_end": 36,
+                "line_start": 1,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                        "highlight_end": 35,
+                        "highlight_start": 1,
+                        "text": "($ left : expr, $ right : expr) =>"
+                    },
+                    {
+                        "highlight_end": 3,
+                        "highlight_start": 1,
+                        "text": "({"
+                    },
+                    {
+                        "highlight_end": 33,
+                        "highlight_start": 1,
+                        "text": "     match (& $ left, & $ right)"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     {"
+                    },
+                    {
+                        "highlight_end": 34,
+                        "highlight_start": 1,
+                        "text": "         (left_val, right_val) =>"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         {"
+                    },
+                    {
+                        "highlight_end": 46,
+                        "highlight_start": 1,
+                        "text": "             if ! (* left_val == * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             {"
+                    },
+                    {
+                        "highlight_end": 25,
+                        "highlight_start": 1,
+                        "text": "                 panic !"
+                    },
+                    {
+                        "highlight_end": 57,
+                        "highlight_start": 1,
+                        "text": "                 (r#\"assertion failed: `(left == right)`"
+                    },
+                    {
+                        "highlight_end": 16,
+                        "highlight_start": 1,
+                        "text": "  left: `{:?}`,"
+                    },
+                    {
+                        "highlight_end": 18,
+                        "highlight_start": 1,
+                        "text": " right: `{:?}`\"#,"
+                    },
+                    {
+                        "highlight_end": 47,
+                        "highlight_start": 1,
+                        "text": "                  & * left_val, & * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             }"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         }"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     }"
+                    },
+                    {
+                        "highlight_end": 42,
+                        "highlight_start": 1,
+                        "text": " }) ; ($ left : expr, $ right : expr,) =>"
+                    },
+                    {
+                        "highlight_end": 49,
+                        "highlight_start": 1,
+                        "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
+                    },
+                    {
+                        "highlight_end": 53,
+                        "highlight_start": 1,
+                        "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
+                    },
+                    {
+                        "highlight_end": 3,
+                        "highlight_start": 1,
+                        "text": "({"
+                    },
+                    {
+                        "highlight_end": 37,
+                        "highlight_start": 1,
+                        "text": "     match (& ($ left), & ($ right))"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     {"
+                    },
+                    {
+                        "highlight_end": 34,
+                        "highlight_start": 1,
+                        "text": "         (left_val, right_val) =>"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         {"
+                    },
+                    {
+                        "highlight_end": 46,
+                        "highlight_start": 1,
+                        "text": "             if ! (* left_val == * right_val)"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             {"
+                    },
+                    {
+                        "highlight_end": 25,
+                        "highlight_start": 1,
+                        "text": "                 panic !"
+                    },
+                    {
+                        "highlight_end": 57,
+                        "highlight_start": 1,
+                        "text": "                 (r#\"assertion failed: `(left == right)`"
+                    },
+                    {
+                        "highlight_end": 16,
+                        "highlight_start": 1,
+                        "text": "  left: `{:?}`,"
+                    },
+                    {
+                        "highlight_end": 22,
+                        "highlight_start": 1,
+                        "text": " right: `{:?}`: {}\"#,"
+                    },
+                    {
+                        "highlight_end": 72,
+                        "highlight_start": 1,
+                        "text": "                  & * left_val, & * right_val, $ crate :: format_args !"
+                    },
+                    {
+                        "highlight_end": 33,
+                        "highlight_start": 1,
+                        "text": "                  ($ ($ arg) +))"
+                    },
+                    {
+                        "highlight_end": 15,
+                        "highlight_start": 1,
+                        "text": "             }"
+                    },
+                    {
+                        "highlight_end": 11,
+                        "highlight_start": 1,
+                        "text": "         }"
+                    },
+                    {
+                        "highlight_end": 7,
+                        "highlight_start": 1,
+                        "text": "     }"
+                    },
+                    {
+                        "highlight_end": 6,
+                        "highlight_start": 1,
+                        "text": " }) ;"
+                    }
+                ]
+            },
+            "macro_decl_name": "assert_eq!",
+            "span": {
+                "byte_end": 38,
+                "byte_start": 16,
+                "column_end": 27,
+                "column_start": 5,
+                "expansion": null,
+                "file_name": "src/main.rs",
+                "is_primary": false,
+                "label": null,
+                "line_end": 2,
+                "line_start": 2,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                        "highlight_end": 27,
+                        "highlight_start": 5,
+                        "text": "    assert_eq!(1, \"love\");"
+                    }
+                ]
+            }
+        },
+        "file_name": "<::core::macros::assert_eq macros>",
+        "is_primary": true,
+        "label": "no implementation for `{integer} == &str`",
+        "line_end": 7,
+        "line_start": 7,
+        "suggested_replacement": null,
+        "suggestion_applicability": null,
+        "text": [
+            {
+                "highlight_end": 33,
+                "highlight_start": 31,
+                "text": "             if ! (* left_val == * right_val)"
+            }
+        ]
+    }
+]
+}"##,
+    );
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    insta::assert_debug_snapshot!(diag);
+}
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
new file mode 100644
index 000000000..e5c22e599
--- /dev/null
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -0,0 +1,392 @@
+//! cargo_check provides the functionality needed to run `cargo check` or
+//! another compatible command (f.x. clippy) in a background thread and provide
+//! LSP diagnostics based on the output of the command.
+use cargo_metadata::Message;
+use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
+use lsp_types::{
+    Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin, WorkDoneProgressEnd,
+    WorkDoneProgressReport,
+};
+use parking_lot::RwLock;
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    process::{Command, Stdio},
+    sync::Arc,
+    thread::JoinHandle,
+    time::Instant,
+};
+mod conv;
+use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic, SuggestedFix};
+#[derive(Clone, Debug)]
+pub struct CheckOptions {
+    pub enable: bool,
+    pub args: Vec<String>,
+    pub command: String,
+    pub all_targets: bool,
+}
+/// CheckWatcher wraps the shared state and communication machinery used for
+/// running `cargo check` (or other compatible command) and providing
+/// diagnostics based on the output.
+/// The spawned thread is shut down when this struct is dropped.
+#[derive(Debug)]
+pub struct CheckWatcher {
+    pub task_recv: Receiver<CheckTask>,
+    pub shared: Arc<RwLock<CheckWatcherSharedState>>,
+    cmd_send: Option<Sender<CheckCommand>>,
+    handle: Option<JoinHandle<()>>,
+}
+impl CheckWatcher {
+    pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
+        let options = options.clone();
+        let shared = Arc::new(RwLock::new(CheckWatcherSharedState::new()));
+        let (task_send, task_recv) = unbounded::<CheckTask>();
+        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
+        let shared_ = shared.clone();
+        let handle = std::thread::spawn(move || {
+            let mut check = CheckWatcherState::new(options, workspace_root, shared_);
+            check.run(&task_send, &cmd_recv);
+        });
+        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle), shared }
+    }
+    /// Schedule a re-start of the cargo check worker.
+    pub fn update(&self) {
+        if let Some(cmd_send) = &self.cmd_send {
+            cmd_send.send(CheckCommand::Update).unwrap();
+        }
+    }
+}
+impl std::ops::Drop for CheckWatcher {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            // Take the sender out of the option
+            let recv = self.cmd_send.take();
+            // Dropping the sender finishes the thread loop
+            drop(recv);
+            // Join the thread, it should finish shortly. We don't really care
+            // whether it panicked, so it is safe to ignore the result
+            let _ = handle.join();
+        }
+    }
+}
+#[derive(Debug)]
+pub struct CheckWatcherSharedState {
+    diagnostic_collection: HashMap<Url, Vec<Diagnostic>>,
+    suggested_fix_collection: HashMap<Url, Vec<SuggestedFix>>,
+}
+impl CheckWatcherSharedState {
+    fn new() -> CheckWatcherSharedState {
+        CheckWatcherSharedState {
+            diagnostic_collection: HashMap::new(),
+            suggested_fix_collection: HashMap::new(),
+        }
+    }
+    /// Clear the cached diagnostics, and schedule updating diagnostics by the
+    /// server, to clear stale results.
+    pub fn clear(&mut self, task_send: &Sender<CheckTask>) {
+        let cleared_files: Vec<Url> = self.diagnostic_collection.keys().cloned().collect();
+        self.diagnostic_collection.clear();
+        self.suggested_fix_collection.clear();
+        for uri in cleared_files {
+            task_send.send(CheckTask::Update(uri.clone())).unwrap();
+        }
+    }
+    pub fn diagnostics_for(&self, uri: &Url) -> Option<&[Diagnostic]> {
+        self.diagnostic_collection.get(uri).map(|d| d.as_slice())
+    }
+    pub fn fixes_for(&self, uri: &Url) -> Option<&[SuggestedFix]> {
+        self.suggested_fix_collection.get(uri).map(|d| d.as_slice())
+    }
+    fn add_diagnostic(&mut self, file_uri: Url, diagnostic: Diagnostic) {
+        let diagnostics = self.diagnostic_collection.entry(file_uri).or_default();
+        // If we're building multiple targets it's possible we've already seen this diagnostic
+        let is_duplicate = diagnostics.iter().any(|d| are_diagnostics_equal(d, &diagnostic));
+        if is_duplicate {
+            return;
+        }
+        diagnostics.push(diagnostic);
+    }
+    fn add_suggested_fix_for_diagnostic(
+        &mut self,
+        mut suggested_fix: SuggestedFix,
+        diagnostic: &Diagnostic,
+    ) {
+        let file_uri = suggested_fix.location.uri.clone();
+        let file_suggestions = self.suggested_fix_collection.entry(file_uri).or_default();
+        let existing_suggestion: Option<&mut SuggestedFix> =
+            file_suggestions.iter_mut().find(|s| s == &&suggested_fix);
+        if let Some(existing_suggestion) = existing_suggestion {
+            // The existing suggestion also applies to this new diagnostic
+            existing_suggestion.diagnostics.push(diagnostic.clone());
+        } else {
+            // We haven't seen this suggestion before
+            suggested_fix.diagnostics.push(diagnostic.clone());
+            file_suggestions.push(suggested_fix);
+        }
+    }
+}
+#[derive(Debug)]
+pub enum CheckTask {
+    /// Request a update of the given files diagnostics
+    Update(Url),
+    /// Request check progress notification to client
+    Status(WorkDoneProgress),
+}
+pub enum CheckCommand {
+    /// Request re-start of check thread
+    Update,
+}
+struct CheckWatcherState {
+    options: CheckOptions,
+    workspace_root: PathBuf,
+    watcher: WatchThread,
+    last_update_req: Option<Instant>,
+    shared: Arc<RwLock<CheckWatcherSharedState>>,
+}
+impl CheckWatcherState {
+    fn new(
+        options: CheckOptions,
+        workspace_root: PathBuf,
+        shared: Arc<RwLock<CheckWatcherSharedState>>,
+    ) -> CheckWatcherState {
+        let watcher = WatchThread::new(&options, &workspace_root);
+        CheckWatcherState { options, workspace_root, watcher, last_update_req: None, shared }
+    }
+    fn run(&mut self, task_send: &Sender<CheckTask>, cmd_recv: &Receiver<CheckCommand>) {
+        loop {
+            select! {
+                recv(&cmd_recv) -> cmd => match cmd {
+                    Ok(cmd) => self.handle_command(cmd),
+                    Err(RecvError) => {
+                        // Command channel has closed, so shut down
+                        break;
+                    },
+                },
+                recv(self.watcher.message_recv) -> msg => match msg {
+                    Ok(msg) => self.handle_message(msg, task_send),
+                    Err(RecvError) => {
+                        // Watcher finished, replace it with a never channel to
+                        // avoid busy-waiting.
+                        std::mem::replace(&mut self.watcher.message_recv, never());
+                    },
+                }
+            };
+            if self.should_recheck() {
+                self.last_update_req.take();
+                self.shared.write().clear(task_send);
+                // By replacing the watcher, we drop the previous one which
+                // causes it to shut down automatically.
+                self.watcher = WatchThread::new(&self.options, &self.workspace_root);
+            }
+        }
+    }
+    fn should_recheck(&mut self) -> bool {
+        if let Some(_last_update_req) = &self.last_update_req {
+            // We currently only request an update on save, as we need up to
+            // date source on disk for cargo check to do it's magic, so we
+            // don't really need to debounce the requests at this point.
+            return true;
+        }
+        false
+    }
+    fn handle_command(&mut self, cmd: CheckCommand) {
+        match cmd {
+            CheckCommand::Update => self.last_update_req = Some(Instant::now()),
+        }
+    }
+    fn handle_message(&mut self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
+        match msg {
+            CheckEvent::Begin => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
+                        title: "Running 'cargo check'".to_string(),
+                        cancellable: Some(false),
+                        message: None,
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::End => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
+                        message: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
+                        cancellable: Some(false),
+                        message: Some(msg.target.name),
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerMessage(msg)) => {
+                let map_result =
+                    match map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root) {
+                        Some(map_result) => map_result,
+                        None => return,
+                    };
+                let MappedRustDiagnostic { location, diagnostic, suggested_fixes } = map_result;
+                let file_uri = location.uri.clone();
+                if !suggested_fixes.is_empty() {
+                    for suggested_fix in suggested_fixes {
+                        self.shared
+                            .write()
+                            .add_suggested_fix_for_diagnostic(suggested_fix, &diagnostic);
+                    }
+                }
+                self.shared.write().add_diagnostic(file_uri, diagnostic);
+                task_send.send(CheckTask::Update(location.uri)).unwrap();
+            }
+            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
+            CheckEvent::Msg(Message::Unknown) => {}
+        }
+    }
+}
+/// WatchThread exists to wrap around the communication needed to be able to
+/// run `cargo check` without blocking. Currently the Rust standard library
+/// doesn't provide a way to read sub-process output without blocking, so we
+/// have to wrap sub-processes output handling in a thread and pass messages
+/// back over a channel.
+/// The correct way to dispose of the thread is to drop it, on which the
+/// sub-process will be killed, and the thread will be joined.
+struct WatchThread {
+    handle: Option<JoinHandle<()>>,
+    message_recv: Receiver<CheckEvent>,
+}
+enum CheckEvent {
+    Begin,
+    Msg(cargo_metadata::Message),
+    End,
+}
+impl WatchThread {
+    fn new(options: &CheckOptions, workspace_root: &PathBuf) -> WatchThread {
+        let mut args: Vec<String> = vec![
+            options.command.clone(),
+            "--message-format=json".to_string(),
+            "--manifest-path".to_string(),
+            format!("{}/Cargo.toml", workspace_root.to_string_lossy()),
+        ];
+        if options.all_targets {
+            args.push("--all-targets".to_string());
+        }
+        args.extend(options.args.iter().cloned());
+        let (message_send, message_recv) = unbounded();
+        let enabled = options.enable;
+        let handle = std::thread::spawn(move || {
+            if !enabled {
+                return;
+            }
+            let mut command = Command::new("cargo")
+                .args(&args)
+                .stdout(Stdio::piped())
+                .stderr(Stdio::null())
+                .spawn()
+                .expect("couldn't launch cargo");
+            // If we trigger an error here, we will do so in the loop instead,
+            // which will break out of the loop, and continue the shutdown
+            let _ = message_send.send(CheckEvent::Begin);
+            for message in cargo_metadata::parse_messages(command.stdout.take().unwrap()) {
+                let message = match message {
+                    Ok(message) => message,
+                    Err(err) => {
+                        log::error!("Invalid json from cargo check, ignoring: {}", err);
+                        continue;
+                    }
+                };
+                match message_send.send(CheckEvent::Msg(message)) {
+                    Ok(()) => {}
+                    Err(_err) => {
+                        // The send channel was closed, so we want to shutdown
+                        break;
+                    }
+                }
+            }
+            // We can ignore any error here, as we are already in the progress
+            // of shutting down.
+            let _ = message_send.send(CheckEvent::End);
+            // It is okay to ignore the result, as it only errors if the process is already dead
+            let _ = command.kill();
+            // Again, we don't care about the exit status so just ignore the result
+            let _ = command.wait();
+        });
+        WatchThread { handle: Some(handle), message_recv }
+    }
+}
+impl std::ops::Drop for WatchThread {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            // Replace our reciever with dummy one, so we can drop and close the
+            // one actually communicating with the thread
+            let recv = std::mem::replace(&mut self.message_recv, never());
+            // Dropping the original reciever initiates thread sub-process shutdown
+            drop(recv);
+            // Join the thread, it should finish shortly. We don't really care
+            // whether it panicked, so it is safe to ignore the result
+            let _ = handle.join();
+        }
+    }
+}
+fn are_diagnostics_equal(left: &Diagnostic, right: &Diagnostic) -> bool {
+    left.source == right.source
+        && left.severity == right.severity
+        && left.range == right.range
+        && left.message == right.message
+}
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index bcfc0d03e..488f74cfb 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -118,7 +118,7 @@ impl_froms!(
    BuiltinType
 );
-pub use hir_def::attr::Attrs;
+pub use hir_def::{attr::Attrs, visibility::Visibility};
 impl Module {
    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
@@ -255,6 +255,15 @@ impl StructField {
    }
 }
+impl HasVisibility for StructField {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let variant_data = self.parent.variant_data(db);
+        let visibility = &variant_data.fields()[self.id].visibility;
+        let parent_id: hir_def::VariantId = self.parent.into();
+        visibility.resolve(db, &parent_id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Struct {
    pub(crate) id: StructId,
@@ -644,6 +653,17 @@ impl_froms!(
    Const
 );
+impl GenericDef {
+    pub fn params(self, db: &impl HirDatabase) -> Vec<TypeParam> {
+        let generics: Arc<hir_def::generics::GenericParams> = db.generic_params(self.into());
+        generics
+            .types
+            .iter()
+            .map(|(local_id, _)| TypeParam { id: TypeParamId { parent: self.into(), local_id } })
+            .collect()
+    }
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Local {
    pub(crate) parent: DefWithBody,
@@ -1030,3 +1050,11 @@ impl<T: Into<AttrDef> + Copy> Docs for T {
        db.documentation(def.into())
    }
 }
+pub trait HasVisibility {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility;
+    fn is_visible_from(&self, db: &impl HirDatabase, module: Module) -> bool {
+        let vis = self.visibility(db);
+        vis.is_visible_from(db, module.id)
+    }
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 0008a8858..3d13978d4 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -40,8 +40,8 @@ mod from_source;
 pub use crate::{
    code_model::{
        Adt, AssocItem, AttrDef, Const, Crate, CrateDependency, DefWithBody, Docs, Enum,
-        EnumVariant, FieldSource, Function, GenericDef, HasAttrs, ImplBlock, Local, MacroDef,
+        EnumVariant, FieldSource, Function, GenericDef, HasAttrs, HasVisibility, ImplBlock, Local,
-        Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
+        MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
        TypeParam, Union, VariantDef,
    },
    from_source::FromSource,
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 85b378483..2c422af8b 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -215,8 +215,32 @@ impl SourceAnalyzer {
        self.body_source_map.as_ref()?.node_pat(src)
    }
+    fn expand_expr(
+        &self,
+        db: &impl HirDatabase,
+        expr: InFile<&ast::Expr>,
+    ) -> Option<InFile<ast::Expr>> {
+        let macro_call = ast::MacroCall::cast(expr.value.syntax().clone())?;
+        let macro_file =
+            self.body_source_map.as_ref()?.node_macro_file(expr.with_value(&macro_call))?;
+        let expanded = db.parse_or_expand(macro_file)?;
+        let kind = expanded.kind();
+        let expr = InFile::new(macro_file, ast::Expr::cast(expanded)?);
+        if ast::MacroCall::can_cast(kind) {
+            self.expand_expr(db, expr.as_ref())
+        } else {
+            Some(expr)
+        }
+    }
    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
-        let expr_id = self.expr_id(expr)?;
+        let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
+            self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
+        } else {
+            self.expr_id(expr)?
+        };
        let ty = self.infer.as_ref()?[expr_id].clone();
        let environment = TraitEnvironment::lower(db, &self.resolver);
        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index d9ea693e3..aac5f3e15 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -9,11 +9,12 @@ use hir_expand::{
 };
 use ra_arena::{map::ArenaMap, Arena};
 use ra_prof::profile;
-use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
+use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
-    db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef, EnumId,
+    db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef,
-    LocalEnumVariantId, LocalStructFieldId, Lookup, StructId, UnionId, VariantId,
+    visibility::RawVisibility, EnumId, LocalEnumVariantId, LocalStructFieldId, Lookup, StructId,
+    UnionId, VariantId,
 };
 /// Note that we use `StructData` for unions as well!
@@ -47,13 +48,14 @@ pub enum VariantData {
 pub struct StructFieldData {
    pub name: Name,
    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
 }
 impl StructData {
    pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructId) -> Arc<StructData> {
        let src = id.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let variant_data = VariantData::new(src.value.kind());
+        let variant_data = VariantData::new(db, src.map(|s| s.kind()));
        let variant_data = Arc::new(variant_data);
        Arc::new(StructData { name, variant_data })
    }
@@ -61,10 +63,12 @@ impl StructData {
        let src = id.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
        let variant_data = VariantData::new(
-            src.value
+            db,
-                .record_field_def_list()
+            src.map(|s| {
-                .map(ast::StructKind::Record)
+                s.record_field_def_list()
-                .unwrap_or(ast::StructKind::Unit),
+                    .map(ast::StructKind::Record)
+                    .unwrap_or(ast::StructKind::Unit)
+            }),
        );
        let variant_data = Arc::new(variant_data);
        Arc::new(StructData { name, variant_data })
@@ -77,7 +81,7 @@ impl EnumData {
        let src = e.lookup(db).source(db);
        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
        let mut trace = Trace::new_for_arena();
-        lower_enum(&mut trace, &src.value);
+        lower_enum(db, &mut trace, &src);
        Arc::new(EnumData { name, variants: trace.into_arena() })
    }
@@ -93,30 +97,31 @@ impl HasChildSource for EnumId {
    fn child_source(&self, db: &impl DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
        let src = self.lookup(db).source(db);
        let mut trace = Trace::new_for_map();
-        lower_enum(&mut trace, &src.value);
+        lower_enum(db, &mut trace, &src);
        src.with_value(trace.into_map())
    }
 }
 fn lower_enum(
+    db: &impl DefDatabase,
    trace: &mut Trace<LocalEnumVariantId, EnumVariantData, ast::EnumVariant>,
-    ast: &ast::EnumDef,
+    ast: &InFile<ast::EnumDef>,
 ) {
-    for var in ast.variant_list().into_iter().flat_map(|it| it.variants()) {
+    for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
        trace.alloc(
            || var.clone(),
            || EnumVariantData {
                name: var.name().map_or_else(Name::missing, |it| it.as_name()),
-                variant_data: Arc::new(VariantData::new(var.kind())),
+                variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()))),
            },
        );
    }
 }
 impl VariantData {
-    fn new(flavor: ast::StructKind) -> Self {
+    fn new(db: &impl DefDatabase, flavor: InFile<ast::StructKind>) -> Self {
        let mut trace = Trace::new_for_arena();
-        match lower_struct(&mut trace, &flavor) {
+        match lower_struct(db, &mut trace, &flavor) {
            StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
            StructKind::Record => VariantData::Record(trace.into_arena()),
            StructKind::Unit => VariantData::Unit,
@@ -163,7 +168,7 @@ impl HasChildSource for VariantId {
            }),
        };
        let mut trace = Trace::new_for_map();
-        lower_struct(&mut trace, &src.value);
+        lower_struct(db, &mut trace, &src);
        src.with_value(trace.into_map())
    }
 }
@@ -175,14 +180,15 @@ enum StructKind {
 }
 fn lower_struct(
+    db: &impl DefDatabase,
    trace: &mut Trace<
        LocalStructFieldId,
        StructFieldData,
        Either<ast::TupleFieldDef, ast::RecordFieldDef>,
    >,
-    ast: &ast::StructKind,
+    ast: &InFile<ast::StructKind>,
 ) -> StructKind {
-    match ast {
+    match &ast.value {
        ast::StructKind::Tuple(fl) => {
            for (i, fd) in fl.fields().enumerate() {
                trace.alloc(
@@ -190,6 +196,7 @@ fn lower_struct(
                    || StructFieldData {
                        name: Name::new_tuple_field(i),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
            }
@@ -202,6 +209,7 @@ fn lower_struct(
                    || StructFieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
                        type_ref: TypeRef::from_ast_opt(fd.ascribed_type()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
            }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index d3e4c50ae..142c52d35 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -163,6 +163,7 @@ pub struct BodySourceMap {
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, PatSource>,
    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
+    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
 }
 impl Body {
@@ -237,6 +238,11 @@ impl BodySourceMap {
        self.expr_map.get(&src).cloned()
    }
+    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<HirFileId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.expansions.get(&src).cloned()
+    }
    pub fn field_init_shorthand_expr(&self, node: InFile<&ast::RecordField>) -> Option<ExprId> {
        let src = node.map(|it| Either::Right(AstPtr::new(it)));
        self.expr_map.get(&src).cloned()
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 5323af097..e656f9a41 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -446,14 +446,20 @@ where
                }
            }
            // FIXME expand to statements in statement position
-            ast::Expr::MacroCall(e) => match self.expander.enter_expand(self.db, e) {
+            ast::Expr::MacroCall(e) => {
-                Some((mark, expansion)) => {
+                let macro_call = self.expander.to_source(AstPtr::new(&e));
-                    let id = self.collect_expr(expansion);
+                match self.expander.enter_expand(self.db, e.clone()) {
-                    self.expander.exit(self.db, mark);
+                    Some((mark, expansion)) => {
-                    id
+                        self.source_map
+                            .expansions
+                            .insert(macro_call, self.expander.current_file_id);
+                        let id = self.collect_expr(expansion);
+                        self.expander.exit(self.db, mark);
+                        id
+                    }
+                    None => self.alloc_expr(Expr::Missing, syntax_ptr),
                }
-                None => self.alloc_expr(Expr::Missing, syntax_ptr),
+            }
-            },
            // FIXME implement HIR for these:
            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
@@ -543,7 +549,10 @@ where
            };
            self.body.item_scope.define_def(def);
            if let Some(name) = name {
-                self.body.item_scope.push_res(name.as_name(), def.into());
+                let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
+                self.body
+                    .item_scope
+                    .push_res(name.as_name(), crate::per_ns::PerNs::from_def(def, vis));
            }
        }
    }
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 1aa9a9b7d..c900a6a18 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -10,8 +10,9 @@ use ra_syntax::ast::{self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAs
 use crate::{
    db::DefDatabase,
+    path::{path, GenericArgs, Path},
    src::HasSource,
-    type_ref::{Mutability, TypeRef},
+    type_ref::{Mutability, TypeBound, TypeRef},
    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
    ImplId, Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
@@ -62,11 +63,29 @@ impl FunctionData {
            TypeRef::unit()
        };
+        let ret_type = if src.value.is_async() {
+            let future_impl = desugar_future_path(ret_type);
+            let ty_bound = TypeBound::Path(future_impl);
+            TypeRef::ImplTrait(vec![ty_bound])
+        } else {
+            ret_type
+        };
        let sig = FunctionData { name, params, ret_type, has_self_param };
        Arc::new(sig)
    }
 }
+fn desugar_future_path(orig: TypeRef) -> Path {
+    let path = path![std::future::Future];
+    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
+    let mut last = GenericArgs::empty();
+    last.bindings.push((name![Output], orig));
+    generic_args.push(Some(Arc::new(last)));
+    Path::from_known_path(path, generic_args)
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TypeAliasData {
    pub name: Name,
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index b0288ee8d..fe7bb9779 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -5,7 +5,10 @@ use hir_expand::name::Name;
 use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
-use crate::{per_ns::PerNs, AdtId, BuiltinType, ImplId, MacroDefId, ModuleDefId, TraitId};
+use crate::{
+    per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId, MacroDefId, ModuleDefId,
+    TraitId,
+};
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ItemScope {
@@ -30,7 +33,7 @@ pub struct ItemScope {
 static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {
    BuiltinType::ALL
        .iter()
-        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into())))
+        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into(), Visibility::Public)))
        .collect()
 });
@@ -144,8 +147,8 @@ impl ItemScope {
        changed
    }
-    pub(crate) fn collect_resolutions(&self) -> Vec<(Name, PerNs)> {
+    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Name, PerNs)> + 'a {
-        self.visible.iter().map(|(name, res)| (name.clone(), res.clone())).collect()
+        self.visible.iter().map(|(name, res)| (name.clone(), res.clone()))
    }
    pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
@@ -153,20 +156,20 @@ impl ItemScope {
    }
 }
-impl From<ModuleDefId> for PerNs {
+impl PerNs {
-    fn from(def: ModuleDefId) -> PerNs {
+    pub(crate) fn from_def(def: ModuleDefId, v: Visibility) -> PerNs {
        match def {
-            ModuleDefId::ModuleId(_) => PerNs::types(def),
+            ModuleDefId::ModuleId(_) => PerNs::types(def, v),
-            ModuleDefId::FunctionId(_) => PerNs::values(def),
+            ModuleDefId::FunctionId(_) => PerNs::values(def, v),
            ModuleDefId::AdtId(adt) => match adt {
-                AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def),
+                AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def, v),
-                AdtId::EnumId(_) => PerNs::types(def),
+                AdtId::EnumId(_) => PerNs::types(def, v),
            },
-            ModuleDefId::EnumVariantId(_) => PerNs::both(def, def),
+            ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
-            ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def),
+            ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
-            ModuleDefId::TraitId(_) => PerNs::types(def),
+            ModuleDefId::TraitId(_) => PerNs::types(def, v),
-            ModuleDefId::TypeAliasId(_) => PerNs::types(def),
+            ModuleDefId::TypeAliasId(_) => PerNs::types(def, v),
-            ModuleDefId::BuiltinType(_) => PerNs::types(def),
+            ModuleDefId::BuiltinType(_) => PerNs::types(def, v),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index f6c7f38d1..61f044ecf 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -36,6 +36,8 @@ pub mod nameres;
 pub mod src;
 pub mod child_by_source;
+pub mod visibility;
 #[cfg(test)]
 mod test_db;
 #[cfg(test)]
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index b9f40d3dd..8a22b0585 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -24,6 +24,7 @@ use crate::{
    },
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::Visibility,
    AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
    LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
@@ -108,7 +109,7 @@ struct MacroDirective {
 struct DefCollector<'a, DB> {
    db: &'a DB,
    def_map: CrateDefMap,
-    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, raw::Import)>>,
+    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility)>>,
    unresolved_imports: Vec<ImportDirective>,
    resolved_imports: Vec<ImportDirective>,
    unexpanded_macros: Vec<MacroDirective>,
@@ -214,7 +215,11 @@ where
        // In Rust, `#[macro_export]` macros are unconditionally visible at the
        // crate root, even if the parent modules is **not** visible.
        if export {
-            self.update(self.def_map.root, &[(name, PerNs::macros(macro_))]);
+            self.update(
+                self.def_map.root,
+                &[(name, PerNs::macros(macro_, Visibility::Public))],
+                Visibility::Public,
+            );
        }
    }
@@ -348,9 +353,12 @@ where
    fn record_resolved_import(&mut self, directive: &ImportDirective) {
        let module_id = directive.module_id;
-        let import_id = directive.import_id;
        let import = &directive.import;
        let def = directive.status.namespaces();
+        let vis = self
+            .def_map
+            .resolve_visibility(self.db, module_id, &directive.import.visibility)
+            .unwrap_or(Visibility::Public);
        if import.is_glob {
            log::debug!("glob import: {:?}", import);
@@ -366,9 +374,16 @@ where
                        let scope = &item_map[m.local_id].scope;
                        // Module scoped macros is included
-                        let items = scope.collect_resolutions();
+                        let items = scope
+                            .resolutions()
-                        self.update(module_id, &items);
+                            // only keep visible names...
+                            .map(|(n, res)| {
+                                (n, res.filter_visibility(|v| v.is_visible_from_other_crate()))
+                            })
+                            .filter(|(_, res)| !res.is_none())
+                            .collect::<Vec<_>>();
+                        self.update(module_id, &items, vis);
                    } else {
                        // glob import from same crate => we do an initial
                        // import, and then need to propagate any further
@@ -376,13 +391,25 @@ where
                        let scope = &self.def_map[m.local_id].scope;
                        // Module scoped macros is included
-                        let items = scope.collect_resolutions();
+                        let items = scope
+                            .resolutions()
-                        self.update(module_id, &items);
+                            // only keep visible names...
+                            .map(|(n, res)| {
+                                (
+                                    n,
+                                    res.filter_visibility(|v| {
+                                        v.is_visible_from_def_map(&self.def_map, module_id)
+                                    }),
+                                )
+                            })
+                            .filter(|(_, res)| !res.is_none())
+                            .collect::<Vec<_>>();
+                        self.update(module_id, &items, vis);
                        // record the glob import in case we add further items
                        let glob = self.glob_imports.entry(m.local_id).or_default();
-                        if !glob.iter().any(|it| *it == (module_id, import_id)) {
+                        if !glob.iter().any(|(mid, _)| *mid == module_id) {
-                            glob.push((module_id, import_id));
+                            glob.push((module_id, vis));
                        }
                    }
                }
@@ -396,11 +423,11 @@ where
                        .map(|(local_id, variant_data)| {
                            let name = variant_data.name.clone();
                            let variant = EnumVariantId { parent: e, local_id };
-                            let res = PerNs::both(variant.into(), variant.into());
+                            let res = PerNs::both(variant.into(), variant.into(), vis);
                            (name, res)
                        })
                        .collect::<Vec<_>>();
-                    self.update(module_id, &resolutions);
+                    self.update(module_id, &resolutions, vis);
                }
                Some(d) => {
                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
@@ -422,21 +449,24 @@ where
                        }
                    }
-                    self.update(module_id, &[(name, def)]);
+                    self.update(module_id, &[(name, def)], vis);
                }
                None => tested_by!(bogus_paths),
            }
        }
    }
-    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, PerNs)]) {
+    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, PerNs)], vis: Visibility) {
-        self.update_recursive(module_id, resolutions, 0)
+        self.update_recursive(module_id, resolutions, vis, 0)
    }
    fn update_recursive(
        &mut self,
        module_id: LocalModuleId,
        resolutions: &[(Name, PerNs)],
+        // All resolutions are imported with this visibility; the visibilies in
+        // the `PerNs` values are ignored and overwritten
+        vis: Visibility,
        depth: usize,
    ) {
        if depth > 100 {
@@ -446,7 +476,7 @@ where
        let scope = &mut self.def_map.modules[module_id].scope;
        let mut changed = false;
        for (name, res) in resolutions {
-            changed |= scope.push_res(name.clone(), *res);
+            changed |= scope.push_res(name.clone(), res.with_visibility(vis));
        }
        if !changed {
@@ -459,9 +489,13 @@ where
            .flat_map(|v| v.iter())
            .cloned()
            .collect::<Vec<_>>();
-        for (glob_importing_module, _glob_import) in glob_imports {
+        for (glob_importing_module, glob_import_vis) in glob_imports {
-            // We pass the glob import so that the tracked import in those modules is that glob import
+            // we know all resolutions have the same visibility (`vis`), so we
-            self.update_recursive(glob_importing_module, resolutions, depth + 1);
+            // just need to check that once
+            if !vis.is_visible_from_def_map(&self.def_map, glob_importing_module) {
+                continue;
+            }
+            self.update_recursive(glob_importing_module, resolutions, glob_import_vis, depth + 1);
        }
    }
@@ -633,9 +667,13 @@ where
        let is_macro_use = attrs.by_key("macro_use").exists();
        match module {
            // inline module, just recurse
-            raw::ModuleData::Definition { name, items, ast_id } => {
+            raw::ModuleData::Definition { name, visibility, items, ast_id } => {
-                let module_id =
+                let module_id = self.push_child_module(
-                    self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None);
+                    name.clone(),
+                    AstId::new(self.file_id, *ast_id),
+                    None,
+                    &visibility,
+                );
                ModCollector {
                    def_collector: &mut *self.def_collector,
@@ -650,7 +688,7 @@ where
                }
            }
            // out of line module, resolve, parse and recurse
-            raw::ModuleData::Declaration { name, ast_id } => {
+            raw::ModuleData::Declaration { name, visibility, ast_id } => {
                let ast_id = AstId::new(self.file_id, *ast_id);
                match self.mod_dir.resolve_declaration(
                    self.def_collector.db,
@@ -659,7 +697,12 @@ where
                    path_attr,
                ) {
                    Ok((file_id, mod_dir)) => {
-                        let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
+                        let module_id = self.push_child_module(
+                            name.clone(),
+                            ast_id,
+                            Some(file_id),
+                            &visibility,
+                        );
                        let raw_items = self.def_collector.db.raw_items(file_id.into());
                        ModCollector {
                            def_collector: &mut *self.def_collector,
@@ -690,7 +733,13 @@ where
        name: Name,
        declaration: AstId<ast::Module>,
        definition: Option<FileId>,
+        visibility: &crate::visibility::RawVisibility,
    ) -> LocalModuleId {
+        let vis = self
+            .def_collector
+            .def_map
+            .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+            .unwrap_or(Visibility::Public);
        let modules = &mut self.def_collector.def_map.modules;
        let res = modules.alloc(ModuleData::default());
        modules[res].parent = Some(self.module_id);
@@ -702,7 +751,7 @@ where
        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
        let def: ModuleDefId = module.into();
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, def.into())]);
+        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis);
        res
    }
@@ -716,6 +765,7 @@ where
        let name = def.name.clone();
        let container = ContainerId::ModuleId(module);
+        let vis = &def.visibility;
        let def: ModuleDefId = match def.kind {
            raw::DefKind::Function(ast_id) => FunctionLoc {
                container: container.into(),
@@ -761,7 +811,12 @@ where
            .into(),
        };
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, def.into())])
+        let vis = self
+            .def_collector
+            .def_map
+            .resolve_visibility(self.def_collector.db, self.module_id, vis)
+            .unwrap_or(Visibility::Public);
+        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis)
    }
    fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 695014c7b..fd6422d60 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -21,6 +21,7 @@ use crate::{
    nameres::{BuiltinShadowMode, CrateDefMap},
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::{RawVisibility, Visibility},
    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
 };
@@ -61,7 +62,35 @@ impl ResolvePathResult {
 impl CrateDefMap {
    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
-        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+        self.extern_prelude
+            .get(name)
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
+    }
+    pub(crate) fn resolve_visibility(
+        &self,
+        db: &impl DefDatabase,
+        original_module: LocalModuleId,
+        visibility: &RawVisibility,
+    ) -> Option<Visibility> {
+        match visibility {
+            RawVisibility::Module(path) => {
+                let (result, remaining) =
+                    self.resolve_path(db, original_module, &path, BuiltinShadowMode::Module);
+                if remaining.is_some() {
+                    return None;
+                }
+                let types = result.take_types()?;
+                match types {
+                    ModuleDefId::ModuleId(m) => Some(Visibility::Module(m)),
+                    _ => {
+                        // error: visibility needs to refer to module
+                        None
+                    }
+                }
+            }
+            RawVisibility::Public => Some(Visibility::Public),
+        }
    }
    // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
@@ -88,17 +117,21 @@ impl CrateDefMap {
            PathKind::DollarCrate(krate) => {
                if krate == self.krate {
                    tested_by!(macro_dollar_crate_self);
-                    PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
+                    PerNs::types(
+                        ModuleId { krate: self.krate, local_id: self.root }.into(),
+                        Visibility::Public,
+                    )
                } else {
                    let def_map = db.crate_def_map(krate);
                    let module = ModuleId { krate, local_id: def_map.root };
                    tested_by!(macro_dollar_crate_other);
-                    PerNs::types(module.into())
+                    PerNs::types(module.into(), Visibility::Public)
                }
            }
-            PathKind::Crate => {
+            PathKind::Crate => PerNs::types(
-                PerNs::types(ModuleId { krate: self.krate, local_id: self.root }.into())
+                ModuleId { krate: self.krate, local_id: self.root }.into(),
-            }
+                Visibility::Public,
+            ),
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -126,7 +159,10 @@ impl CrateDefMap {
                let m = successors(Some(original_module), |m| self.modules[*m].parent)
                    .nth(lvl as usize);
                if let Some(local_id) = m {
-                    PerNs::types(ModuleId { krate: self.krate, local_id }.into())
+                    PerNs::types(
+                        ModuleId { krate: self.krate, local_id }.into(),
+                        Visibility::Public,
+                    )
                } else {
                    log::debug!("super path in root module");
                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -140,7 +176,7 @@ impl CrateDefMap {
                };
                if let Some(def) = self.extern_prelude.get(&segment) {
                    log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
-                    PerNs::types(*def)
+                    PerNs::types(*def, Visibility::Public)
                } else {
                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
                }
@@ -148,7 +184,7 @@ impl CrateDefMap {
        };
        for (i, segment) in segments {
-            let curr = match curr_per_ns.take_types() {
+            let (curr, vis) = match curr_per_ns.take_types_vis() {
                Some(r) => r,
                None => {
                    // we still have path segments left, but the path so far
@@ -189,11 +225,11 @@ impl CrateDefMap {
                    match enum_data.variant(&segment) {
                        Some(local_id) => {
                            let variant = EnumVariantId { parent: e, local_id };
-                            PerNs::both(variant.into(), variant.into())
+                            PerNs::both(variant.into(), variant.into(), Visibility::Public)
                        }
                        None => {
                            return ResolvePathResult::with(
-                                PerNs::types(e.into()),
+                                PerNs::types(e.into(), vis),
                                ReachedFixedPoint::Yes,
                                Some(i),
                                Some(self.krate),
@@ -211,7 +247,7 @@ impl CrateDefMap {
                    );
                    return ResolvePathResult::with(
-                        PerNs::types(s),
+                        PerNs::types(s, vis),
                        ReachedFixedPoint::Yes,
                        Some(i),
                        Some(self.krate),
@@ -235,11 +271,15 @@ impl CrateDefMap {
        //  - current module / scope
        //  - extern prelude
        //  - std prelude
-        let from_legacy_macro =
+        let from_legacy_macro = self[module]
-            self[module].scope.get_legacy_macro(name).map_or_else(PerNs::none, PerNs::macros);
+            .scope
+            .get_legacy_macro(name)
+            .map_or_else(PerNs::none, |m| PerNs::macros(m, Visibility::Public));
        let from_scope = self[module].scope.get(name, shadow);
-        let from_extern_prelude =
+        let from_extern_prelude = self
-            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
+            .extern_prelude
+            .get(name)
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
        let from_prelude = self.resolve_in_prelude(db, name, shadow);
        from_legacy_macro.or(from_scope).or(from_extern_prelude).or(from_prelude)
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 73dc08745..fac1169ef 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -16,12 +16,15 @@ use hir_expand::{
 use ra_arena::{impl_arena_id, Arena, RawId};
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner},
+    ast::{self, AttrsOwner, NameOwner, VisibilityOwner},
    AstNode,
 };
 use test_utils::tested_by;
-use crate::{attr::Attrs, db::DefDatabase, path::ModPath, FileAstId, HirFileId, InFile};
+use crate::{
+    attr::Attrs, db::DefDatabase, path::ModPath, visibility::RawVisibility, FileAstId, HirFileId,
+    InFile,
+};
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -122,8 +125,17 @@ impl_arena_id!(Module);
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module> },
+    Declaration {
-    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
+        name: Name,
+        visibility: RawVisibility,
+        ast_id: FileAstId<ast::Module>,
+    },
+    Definition {
+        name: Name,
+        visibility: RawVisibility,
+        ast_id: FileAstId<ast::Module>,
+        items: Vec<RawItem>,
+    },
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -138,6 +150,7 @@ pub struct ImportData {
    pub(super) is_prelude: bool,
    pub(super) is_extern_crate: bool,
    pub(super) is_macro_use: bool,
+    pub(super) visibility: RawVisibility,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -148,6 +161,7 @@ impl_arena_id!(Def);
 pub(super) struct DefData {
    pub(super) name: Name,
    pub(super) kind: DefKind,
+    pub(super) visibility: RawVisibility,
 }
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -218,6 +232,7 @@ impl RawItemsCollector {
    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
        let attrs = self.parse_attrs(&item);
+        let visibility = RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene);
        let (kind, name) = match item {
            ast::ModuleItem::Module(module) => {
                self.add_module(current_module, module);
@@ -266,7 +281,7 @@ impl RawItemsCollector {
        };
        if let Some(name) = name {
            let name = name.as_name();
-            let def = self.raw_items.defs.alloc(DefData { name, kind });
+            let def = self.raw_items.defs.alloc(DefData { name, kind, visibility });
            self.push_item(current_module, attrs, RawItemKind::Def(def));
        }
    }
@@ -277,10 +292,12 @@ impl RawItemsCollector {
            None => return,
        };
        let attrs = self.parse_attrs(&module);
+        let visibility = RawVisibility::from_ast_with_hygiene(module.visibility(), &self.hygiene);
        let ast_id = self.source_ast_id_map.ast_id(&module);
        if module.has_semi() {
-            let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id });
+            let item =
+                self.raw_items.modules.alloc(ModuleData::Declaration { name, visibility, ast_id });
            self.push_item(current_module, attrs, RawItemKind::Module(item));
            return;
        }
@@ -288,6 +305,7 @@ impl RawItemsCollector {
        if let Some(item_list) = module.item_list() {
            let item = self.raw_items.modules.alloc(ModuleData::Definition {
                name,
+                visibility,
                ast_id,
                items: Vec::new(),
            });
@@ -302,6 +320,7 @@ impl RawItemsCollector {
        // FIXME: cfg_attr
        let is_prelude = use_item.has_atom_attr("prelude_import");
        let attrs = self.parse_attrs(&use_item);
+        let visibility = RawVisibility::from_ast_with_hygiene(use_item.visibility(), &self.hygiene);
        let mut buf = Vec::new();
        ModPath::expand_use_item(
@@ -315,6 +334,7 @@ impl RawItemsCollector {
                    is_prelude,
                    is_extern_crate: false,
                    is_macro_use: false,
+                    visibility: visibility.clone(),
                };
                buf.push(import_data);
            },
@@ -331,6 +351,8 @@ impl RawItemsCollector {
    ) {
        if let Some(name_ref) = extern_crate.name_ref() {
            let path = ModPath::from_name_ref(&name_ref);
+            let visibility =
+                RawVisibility::from_ast_with_hygiene(extern_crate.visibility(), &self.hygiene);
            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
            let attrs = self.parse_attrs(&extern_crate);
            // FIXME: cfg_attr
@@ -342,6 +364,7 @@ impl RawItemsCollector {
                is_prelude: false,
                is_extern_crate: true,
                is_macro_use,
+                visibility,
            };
            self.push_import(current_module, attrs, import_data);
        }
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index ff474b53b..78bcdc850 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -12,8 +12,8 @@ use test_utils::covers;
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
-fn def_map(fixtute: &str) -> String {
+fn def_map(fixture: &str) -> String {
-    let dm = compute_crate_def_map(fixtute);
+    let dm = compute_crate_def_map(fixture);
    render_crate_def_map(&dm)
 }
@@ -32,7 +32,7 @@ fn render_crate_def_map(map: &CrateDefMap) -> String {
        *buf += path;
        *buf += "\n";
-        let mut entries = map.modules[module].scope.collect_resolutions();
+        let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
        entries.sort_by_key(|(name, _)| name.clone());
        for (name, def) in entries {
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 5e24cb94d..71fa0abe8 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -74,6 +74,83 @@ fn glob_2() {
 }
 #[test]
+fn glob_privacy_1() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::*;
+        struct PrivateStructFoo;
+        //- /foo/bar.rs
+        pub struct Baz;
+        struct PrivateStructBar;
+        pub use super::*;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+    crate
+    Baz: t v
+    bar: t
+    foo: t
+    
+    crate::foo
+    Baz: t v
+    PrivateStructFoo: t v
+    bar: t
+    
+    crate::foo::bar
+    Baz: t v
+    PrivateStructBar: t v
+    PrivateStructFoo: t v
+    bar: t
+    "###
+    );
+}
+#[test]
+fn glob_privacy_2() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        use foo::bar::*;
+        //- /foo/mod.rs
+        mod bar;
+        fn Foo() {};
+        pub struct Foo {};
+        //- /foo/bar.rs
+        pub(super) struct PrivateBaz;
+        struct PrivateBar;
+        pub(crate) struct PubCrateStruct;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+    crate
+    Foo: t
+    PubCrateStruct: t v
+    foo: t
+    
+    crate::foo
+    Foo: t v
+    bar: t
+    
+    crate::foo::bar
+    PrivateBar: t v
+    PrivateBaz: t v
+    PubCrateStruct: t v
+    "###
+    );
+}
+#[test]
 fn glob_across_crates() {
    covers!(glob_across_crates);
    let map = def_map(
@@ -93,6 +170,26 @@ fn glob_across_crates() {
 }
 #[test]
+fn glob_privacy_across_crates() {
+    covers!(glob_across_crates);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::*;
+        //- /lib.rs crate:test_crate
+        pub struct Baz;
+        struct Foo;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Baz: t v
+    "###
+    );
+}
+#[test]
 fn glob_enum() {
    covers!(glob_enum);
    let map = def_map(
diff --git a/crates/ra_hir_def/src/nameres/tests/incremental.rs b/crates/ra_hir_def/src/nameres/tests/incremental.rs
index ef2e9435c..faeb7aa4d 100644
--- a/crates/ra_hir_def/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir_def/src/nameres/tests/incremental.rs
@@ -116,7 +116,7 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
        let events = db.log_executed(|| {
            let crate_def_map = db.crate_def_map(krate);
            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
-            assert_eq!(module_data.scope.collect_resolutions().len(), 1);
+            assert_eq!(module_data.scope.resolutions().collect::<Vec<_>>().len(), 1);
        });
        assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
    }
@@ -126,7 +126,7 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
        let events = db.log_executed(|| {
            let crate_def_map = db.crate_def_map(krate);
            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
-            assert_eq!(module_data.scope.collect_resolutions().len(), 1);
+            assert_eq!(module_data.scope.resolutions().collect::<Vec<_>>().len(), 1);
        });
        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
    }
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 8e1294201..107d2d799 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -130,6 +130,14 @@ impl Path {
        Path { type_anchor: None, mod_path: name_ref.as_name().into(), generic_args: vec![None] }
    }
+    /// Converts a known mod path to `Path`.
+    pub(crate) fn from_known_path(
+        path: ModPath,
+        generic_args: Vec<Option<Arc<GenericArgs>>>,
+    ) -> Path {
+        Path { type_anchor: None, mod_path: path, generic_args }
+    }
    pub fn kind(&self) -> &PathKind {
        &self.mod_path.kind
    }
diff --git a/crates/ra_hir_def/src/per_ns.rs b/crates/ra_hir_def/src/per_ns.rs
index 3a5105028..6e435c8c1 100644
--- a/crates/ra_hir_def/src/per_ns.rs
+++ b/crates/ra_hir_def/src/per_ns.rs
@@ -5,13 +5,13 @@
 use hir_expand::MacroDefId;
-use crate::ModuleDefId;
+use crate::{visibility::Visibility, ModuleDefId};
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct PerNs {
-    pub types: Option<ModuleDefId>,
+    pub types: Option<(ModuleDefId, Visibility)>,
-    pub values: Option<ModuleDefId>,
+    pub values: Option<(ModuleDefId, Visibility)>,
-    pub macros: Option<MacroDefId>,
+    pub macros: Option<(MacroDefId, Visibility)>,
 }
 impl Default for PerNs {
@@ -25,20 +25,20 @@ impl PerNs {
        PerNs { types: None, values: None, macros: None }
    }
-    pub fn values(t: ModuleDefId) -> PerNs {
+    pub fn values(t: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: None, values: Some(t), macros: None }
+        PerNs { types: None, values: Some((t, v)), macros: None }
    }
-    pub fn types(t: ModuleDefId) -> PerNs {
+    pub fn types(t: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: Some(t), values: None, macros: None }
+        PerNs { types: Some((t, v)), values: None, macros: None }
    }
-    pub fn both(types: ModuleDefId, values: ModuleDefId) -> PerNs {
+    pub fn both(types: ModuleDefId, values: ModuleDefId, v: Visibility) -> PerNs {
-        PerNs { types: Some(types), values: Some(values), macros: None }
+        PerNs { types: Some((types, v)), values: Some((values, v)), macros: None }
    }
-    pub fn macros(macro_: MacroDefId) -> PerNs {
+    pub fn macros(macro_: MacroDefId, v: Visibility) -> PerNs {
-        PerNs { types: None, values: None, macros: Some(macro_) }
+        PerNs { types: None, values: None, macros: Some((macro_, v)) }
    }
    pub fn is_none(&self) -> bool {
@@ -46,15 +46,35 @@ impl PerNs {
    }
    pub fn take_types(self) -> Option<ModuleDefId> {
+        self.types.map(|it| it.0)
+    }
+    pub fn take_types_vis(self) -> Option<(ModuleDefId, Visibility)> {
        self.types
    }
    pub fn take_values(self) -> Option<ModuleDefId> {
-        self.values
+        self.values.map(|it| it.0)
    }
    pub fn take_macros(self) -> Option<MacroDefId> {
-        self.macros
+        self.macros.map(|it| it.0)
+    }
+    pub fn filter_visibility(self, mut f: impl FnMut(Visibility) -> bool) -> PerNs {
+        PerNs {
+            types: self.types.filter(|(_, v)| f(*v)),
+            values: self.values.filter(|(_, v)| f(*v)),
+            macros: self.macros.filter(|(_, v)| f(*v)),
+        }
+    }
+    pub fn with_visibility(self, vis: Visibility) -> PerNs {
+        PerNs {
+            types: self.types.map(|(it, _)| (it, vis)),
+            values: self.values.map(|(it, _)| (it, vis)),
+            macros: self.macros.map(|(it, _)| (it, vis)),
+        }
    }
    pub fn or(self, other: PerNs) -> PerNs {
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index cf3c33d78..5d16dd087 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -19,6 +19,7 @@ use crate::{
    nameres::CrateDefMap,
    path::{ModPath, PathKind},
    per_ns::PerNs,
+    visibility::{RawVisibility, Visibility},
    AdtId, AssocContainerId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId,
    FunctionId, GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
    StaticId, StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
@@ -231,6 +232,23 @@ impl Resolver {
        Some(res)
    }
+    pub fn resolve_visibility(
+        &self,
+        db: &impl DefDatabase,
+        visibility: &RawVisibility,
+    ) -> Option<Visibility> {
+        match visibility {
+            RawVisibility::Module(_) => {
+                let (item_map, module) = match self.module() {
+                    Some(it) => it,
+                    None => return None,
+                };
+                item_map.resolve_visibility(db, module, visibility)
+            }
+            RawVisibility::Public => Some(Visibility::Public),
+        }
+    }
    pub fn resolve_path_in_value_ns(
        &self,
        db: &impl DefDatabase,
@@ -448,10 +466,10 @@ impl Scope {
                    f(name.clone(), ScopeDef::PerNs(def));
                });
                m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
-                    f(name.clone(), ScopeDef::PerNs(PerNs::macros(macro_)));
+                    f(name.clone(), ScopeDef::PerNs(PerNs::macros(macro_, Visibility::Public)));
                });
                m.crate_def_map.extern_prelude.iter().for_each(|(name, &def)| {
-                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def.into())));
+                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def.into(), Visibility::Public)));
                });
                if let Some(prelude) = m.crate_def_map.prelude {
                    let prelude_def_map = db.crate_def_map(prelude.krate);
@@ -626,7 +644,7 @@ impl HasResolver for ContainerId {
    fn resolver(self, db: &impl DefDatabase) -> Resolver {
        match self {
            ContainerId::ModuleId(it) => it.resolver(db),
-            ContainerId::DefWithBodyId(it) => it.resolver(db),
+            ContainerId::DefWithBodyId(it) => it.module(db).resolver(db),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs
new file mode 100644
index 000000000..d8296da4b
--- /dev/null
+++ b/crates/ra_hir_def/src/visibility.rs
@@ -0,0 +1,120 @@
+//! Defines hir-level representation of visibility (e.g. `pub` and `pub(crate)`).
+use hir_expand::{hygiene::Hygiene, InFile};
+use ra_syntax::ast;
+use crate::{
+    db::DefDatabase,
+    path::{ModPath, PathKind},
+    ModuleId,
+};
+/// Visibility of an item, not yet resolved.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RawVisibility {
+    /// `pub(in module)`, `pub(crate)` or `pub(super)`. Also private, which is
+    /// equivalent to `pub(self)`.
+    Module(ModPath),
+    /// `pub`.
+    Public,
+}
+impl RawVisibility {
+    const fn private() -> RawVisibility {
+        let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
+        RawVisibility::Module(path)
+    }
+    pub(crate) fn from_ast(
+        db: &impl DefDatabase,
+        node: InFile<Option<ast::Visibility>>,
+    ) -> RawVisibility {
+        Self::from_ast_with_hygiene(node.value, &Hygiene::new(db, node.file_id))
+    }
+    pub(crate) fn from_ast_with_hygiene(
+        node: Option<ast::Visibility>,
+        hygiene: &Hygiene,
+    ) -> RawVisibility {
+        let node = match node {
+            None => return RawVisibility::private(),
+            Some(node) => node,
+        };
+        match node.kind() {
+            ast::VisibilityKind::In(path) => {
+                let path = ModPath::from_src(path, hygiene);
+                let path = match path {
+                    None => return RawVisibility::private(),
+                    Some(path) => path,
+                };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::PubCrate => {
+                let path = ModPath { kind: PathKind::Crate, segments: Vec::new() };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::PubSuper => {
+                let path = ModPath { kind: PathKind::Super(1), segments: Vec::new() };
+                RawVisibility::Module(path)
+            }
+            ast::VisibilityKind::Pub => RawVisibility::Public,
+        }
+    }
+    pub fn resolve(
+        &self,
+        db: &impl DefDatabase,
+        resolver: &crate::resolver::Resolver,
+    ) -> Visibility {
+        // we fall back to public visibility (i.e. fail open) if the path can't be resolved
+        resolver.resolve_visibility(db, self).unwrap_or(Visibility::Public)
+    }
+}
+/// Visibility of an item, with the path resolved.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Visibility {
+    /// Visibility is restricted to a certain module.
+    Module(ModuleId),
+    /// Visibility is unrestricted.
+    Public,
+}
+impl Visibility {
+    pub fn is_visible_from(self, db: &impl DefDatabase, from_module: ModuleId) -> bool {
+        let to_module = match self {
+            Visibility::Module(m) => m,
+            Visibility::Public => return true,
+        };
+        // if they're not in the same crate, it can't be visible
+        if from_module.krate != to_module.krate {
+            return false;
+        }
+        let def_map = db.crate_def_map(from_module.krate);
+        self.is_visible_from_def_map(&def_map, from_module.local_id)
+    }
+    pub(crate) fn is_visible_from_other_crate(self) -> bool {
+        match self {
+            Visibility::Module(_) => false,
+            Visibility::Public => true,
+        }
+    }
+    pub(crate) fn is_visible_from_def_map(
+        self,
+        def_map: &crate::nameres::CrateDefMap,
+        from_module: crate::LocalModuleId,
+    ) -> bool {
+        let to_module = match self {
+            Visibility::Module(m) => m,
+            Visibility::Public => return true,
+        };
+        // from_module needs to be a descendant of to_module
+        let mut ancestors = std::iter::successors(Some(from_module), |m| {
+            let parent_id = def_map[*m].parent?;
+            Some(parent_id)
+        });
+        ancestors.any(|m| m == to_module.local_id)
+    }
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index dcca1bace..37def7c03 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -10,7 +10,7 @@ pub struct HirFormatter<'a, 'b, DB> {
    buf: String,
    curr_size: usize,
    max_size: Option<usize>,
-    should_display_default_types: bool,
+    omit_verbose_types: bool,
 }
 pub trait HirDisplay {
@@ -20,7 +20,7 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, None, true)
+        HirDisplayWrapper(db, self, None, false)
    }
    fn display_truncated<'a, DB>(
@@ -31,7 +31,7 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, max_size, false)
+        HirDisplayWrapper(db, self, max_size, true)
    }
 }
@@ -74,8 +74,8 @@ where
        }
    }
-    pub fn should_display_default_types(&self) -> bool {
+    pub fn omit_verbose_types(&self) -> bool {
-        self.should_display_default_types
+        self.omit_verbose_types
    }
 }
@@ -93,7 +93,7 @@ where
            buf: String::with_capacity(20),
            curr_size: 0,
            max_size: self.2,
-            should_display_default_types: self.3,
+            omit_verbose_types: self.3,
        })
    }
 }
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index e97b81473..32c0d07a5 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -37,8 +37,8 @@ use test_utils::tested_by;
 use super::{
    primitive::{FloatTy, IntTy},
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
+    ApplicationTy, GenericPredicate, InEnvironment, ProjectionTy, Substs, TraitEnvironment,
-    TypeWalk, Uncertain,
+    TraitRef, Ty, TypeCtor, TypeWalk, Uncertain,
 };
 use crate::{db::HirDatabase, infer::diagnostics::InferenceDiagnostic};
@@ -379,6 +379,25 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    ) -> Ty {
        match assoc_ty {
            Some(res_assoc_ty) => {
+                // FIXME:
+                // Check if inner_ty is is `impl Trait` and contained input TypeAlias id
+                // this is a workaround while Chalk assoc type projection doesn't always work yet,
+                // but once that is fixed I don't think we should keep this
+                // (we'll probably change how associated types are resolved anyway)
+                if let Ty::Opaque(ref predicates) = inner_ty {
+                    for p in predicates.iter() {
+                        if let GenericPredicate::Projection(projection) = p {
+                            if projection.projection_ty.associated_ty == res_assoc_ty {
+                                if let ty_app!(_, params) = &projection.ty {
+                                    if params.len() == 0 {
+                                        return projection.ty.clone();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                let ty = self.table.new_type_var();
                let builder = Substs::build_for_def(self.db, res_assoc_ty)
                    .push(inner_ty)
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 48abf97c9..55b6dd836 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -821,6 +821,8 @@ impl TypeWalk for Ty {
    }
 }
+const TYPE_HINT_TRUNCATION: &str = "…";
 impl HirDisplay for &Ty {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        HirDisplay::hir_fmt(*self, f)
@@ -830,7 +832,7 @@ impl HirDisplay for &Ty {
 impl HirDisplay for ApplicationTy {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        if f.should_truncate() {
-            return write!(f, "…");
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
        match self.ctor {
@@ -908,9 +910,7 @@ impl HirDisplay for ApplicationTy {
                    write!(f, "<")?;
                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
-                    let parameters_to_write = if f.should_display_default_types() {
+                    let parameters_to_write = if f.omit_verbose_types() {
-                        self.parameters.0.as_ref()
-                    } else {
                        match self
                            .ctor
                            .as_generic_def()
@@ -935,6 +935,8 @@ impl HirDisplay for ApplicationTy {
                                &non_default_parameters
                            }
                        }
+                    } else {
+                        self.parameters.0.as_ref()
                    };
                    f.write_joined(parameters_to_write, ", ")?;
@@ -959,9 +961,16 @@ impl HirDisplay for ApplicationTy {
                let sig = self.parameters[0]
                    .callable_sig(f.db)
                    .expect("first closure parameter should contain signature");
-                write!(f, "|")?;
+                let return_type_hint = sig.ret().display(f.db);
-                f.write_joined(sig.params(), ", ")?;
+                if sig.params().is_empty() {
-                write!(f, "| -> {}", sig.ret().display(f.db))?;
+                    write!(f, "|| -> {}", return_type_hint)?;
+                } else if f.omit_verbose_types() {
+                    write!(f, "|{}| -> {}", TYPE_HINT_TRUNCATION, return_type_hint)?;
+                } else {
+                    write!(f, "|")?;
+                    f.write_joined(sig.params(), ", ")?;
+                    write!(f, "| -> {}", return_type_hint)?;
+                };
            }
        }
        Ok(())
@@ -971,7 +980,7 @@ impl HirDisplay for ApplicationTy {
 impl HirDisplay for ProjectionTy {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        if f.should_truncate() {
-            return write!(f, "…");
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
        let trait_name = f.db.trait_data(self.trait_(f.db)).name.clone();
@@ -989,7 +998,7 @@ impl HirDisplay for ProjectionTy {
 impl HirDisplay for Ty {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        if f.should_truncate() {
-            return write!(f, "…");
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
        match self {
@@ -1074,7 +1083,7 @@ impl HirDisplay for Ty {
 impl TraitRef {
    fn hir_fmt_ext(&self, f: &mut HirFormatter<impl HirDatabase>, use_as: bool) -> fmt::Result {
        if f.should_truncate() {
-            return write!(f, "…");
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
        self.substs[0].hir_fmt(f)?;
@@ -1108,7 +1117,7 @@ impl HirDisplay for &GenericPredicate {
 impl HirDisplay for GenericPredicate {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        if f.should_truncate() {
-            return write!(f, "…");
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
        match self {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index d447b4571..d1f10e675 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -11,8 +11,8 @@ use std::fmt::Write;
 use std::sync::Arc;
 use hir_def::{
-    body::BodySourceMap, child_by_source::ChildBySource, db::DefDatabase, keys,
+    body::BodySourceMap, child_by_source::ChildBySource, db::DefDatabase, item_scope::ItemScope,
-    nameres::CrateDefMap, AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
+    keys, nameres::CrateDefMap, AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::InFile;
 use insta::assert_snapshot;
@@ -163,35 +163,69 @@ fn visit_module(
    module_id: LocalModuleId,
    cb: &mut dyn FnMut(DefWithBodyId),
 ) {
-    for decl in crate_def_map[module_id].scope.declarations() {
+    visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb);
-        match decl {
-            ModuleDefId::FunctionId(it) => cb(it.into()),
-            ModuleDefId::ConstId(it) => cb(it.into()),
-            ModuleDefId::StaticId(it) => cb(it.into()),
-            ModuleDefId::TraitId(it) => {
-                let trait_data = db.trait_data(it);
-                for &(_, item) in trait_data.items.iter() {
-                    match item {
-                        AssocItemId::FunctionId(it) => cb(it.into()),
-                        AssocItemId::ConstId(it) => cb(it.into()),
-                        AssocItemId::TypeAliasId(_) => (),
-                    }
-                }
-            }
-            ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
-            _ => (),
-        }
-    }
    for impl_id in crate_def_map[module_id].scope.impls() {
        let impl_data = db.impl_data(impl_id);
        for &item in impl_data.items.iter() {
            match item {
-                AssocItemId::FunctionId(it) => cb(it.into()),
+                AssocItemId::FunctionId(it) => {
-                AssocItemId::ConstId(it) => cb(it.into()),
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                AssocItemId::ConstId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
                AssocItemId::TypeAliasId(_) => (),
            }
        }
    }
+    fn visit_scope(
+        db: &TestDB,
+        crate_def_map: &CrateDefMap,
+        scope: &ItemScope,
+        cb: &mut dyn FnMut(DefWithBodyId),
+    ) {
+        for decl in scope.declarations() {
+            match decl {
+                ModuleDefId::FunctionId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::ConstId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::StaticId(it) => {
+                    let def = it.into();
+                    cb(def);
+                    let body = db.body(def);
+                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                }
+                ModuleDefId::TraitId(it) => {
+                    let trait_data = db.trait_data(it);
+                    for &(_, item) in trait_data.items.iter() {
+                        match item {
+                            AssocItemId::FunctionId(it) => cb(it.into()),
+                            AssocItemId::ConstId(it) => cb(it.into()),
+                            AssocItemId::TypeAliasId(_) => (),
+                        }
+                    }
+                }
+                ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
+                _ => (),
+            }
+        }
+    }
 }
 fn ellipsize(mut text: String, max_len: usize) -> String {
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 09d684ac2..8b3aa8564 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,7 +1,8 @@
-use super::infer;
 use insta::assert_snapshot;
 use test_utils::covers;
+use super::infer;
 #[test]
 fn bug_484() {
    assert_snapshot!(
@@ -331,3 +332,36 @@ pub fn main_loop() {
    "###
    );
 }
+#[test]
+fn issue_2669() {
+    assert_snapshot!(
+        infer(
+            r#"trait A {}
+    trait Write {}
+    struct Response<T> {}
+    trait D {
+        fn foo();
+    }
+    impl<T:A> D for Response<T> {
+        fn foo() {
+            end();
+            fn end<W: Write>() {
+                let _x: T =  loop {};
+            }
+        }
+    }"#
+        ),
+        @r###"
+    [147; 262) '{     ...     }': ()
+    [161; 164) 'end': fn end<{unknown}>() -> ()
+    [161; 166) 'end()': ()
+    [199; 252) '{     ...     }': ()
+    [221; 223) '_x': !
+    [230; 237) 'loop {}': !
+    [235; 237) '{}': ()
+    "###
+    )
+}
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 3e5e163e3..00134c99b 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1518,6 +1518,7 @@ fn test() {
    [167; 179) 'GLOBAL_CONST': u32
    [189; 191) 'id': u32
    [194; 210) 'Foo::A..._CONST': u32
+    [126; 128) '99': u32
    "###
    );
 }
@@ -1549,6 +1550,8 @@ fn test() {
    [233; 246) 'GLOBAL_STATIC': u32
    [256; 257) 'w': u32
    [260; 277) 'GLOBAL...IC_MUT': u32
+    [118; 120) '99': u32
+    [161; 163) '99': u32
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index ae316922b..0bc72644a 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -38,6 +38,63 @@ mod future {
 }
 #[test]
+fn infer_async() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main deps:std
+async fn foo() -> u64 {
+    128
+}
+fn test() {
+    let r = foo();
+    let v = r.await;
+    v<|>;
+}
+//- /std.rs crate:std
+#[prelude_import] use future::*;
+mod future {
+    trait Future {
+        type Output;
+    }
+}
+"#,
+    );
+    assert_eq!("u64", type_at_pos(&db, pos));
+}
+#[test]
+fn infer_desugar_async() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main deps:std
+async fn foo() -> u64 {
+    128
+}
+fn test() {
+    let r = foo();
+    r<|>;
+}
+//- /std.rs crate:std
+#[prelude_import] use future::*;
+mod future {
+    trait Future {
+        type Output;
+    }
+}
+"#,
+    );
+    assert_eq!("impl Future<Output = u64>", type_at_pos(&db, pos));
+}
+#[test]
 fn infer_try() {
    let (db, pos) = TestDB::with_position(
        r#"
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 294964887..210a685e4 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use hir::Type;
+use hir::{HasVisibility, Type};
 use crate::completion::completion_item::CompletionKind;
 use crate::{
@@ -38,9 +38,15 @@ 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.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;
+            }
            acc.add_field(ctx, field, &ty);
        }
        for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
+            // FIXME: Handle visibility
            acc.add_tuple_field(ctx, i, &ty);
        }
    }
@@ -187,6 +193,55 @@ mod tests {
    }
    #[test]
+    fn test_struct_field_visibility_private() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            mod inner {
+                struct A {
+                    private_field: u32,
+                    pub pub_field: u32,
+                    pub(crate) crate_field: u32,
+                    pub(super) super_field: u32,
+                }
+            }
+            fn foo(a: inner::A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "crate_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "crate_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "pub_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "pub_field",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "super_field",
+                source_range: [313; 313),
+                delete: [313; 313),
+                insert: "super_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn test_method_completion() {
        assert_debug_snapshot!(
        do_ref_completion(
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index c5e406977..977aafc51 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -293,7 +293,7 @@ fn main() {
    }
    #[test]
-    fn closure_parameter() {
+    fn closure_parameters() {
        let (analysis, file_id) = single_file(
            r#"
 fn main() {
@@ -301,6 +301,11 @@ fn main() {
    (0..2).for_each(|increment| {
        start += increment;
    })
+    let multiply = |a, b, c, d| a * b * c * d;
+    let _: i32 = multiply(1, 2, 3, 4);
+    let return_42 = || 42;
 }"#,
        );
@@ -316,6 +321,36 @@ fn main() {
                kind: TypeHint,
                label: "i32",
            },
+            InlayHint {
+                range: [114; 122),
+                kind: TypeHint,
+                label: "|…| -> i32",
+            },
+            InlayHint {
+                range: [126; 127),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [129; 130),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [132; 133),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [135; 136),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [201; 210),
+                kind: TypeHint,
+                label: "|| -> i32",
+            },
        ]
        "###
        );
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 60cbc38a9..9b7dcb6e9 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -14,7 +14,7 @@ serde_json = "1.0.34"
 serde = { version = "1.0.83", features = ["derive"] }
 crossbeam-channel = "0.4"
 log = "0.4.3"
-lsp-types = { version = "0.66.0", features = ["proposed"] }
+lsp-types = { version = "0.67.0", features = ["proposed"] }
 rustc-hash = "1.0"
 parking_lot = "0.10.0"
 jod-thread = "0.1.0"
@@ -27,6 +27,7 @@ ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
 ra_vfs_glob = { path = "../ra_vfs_glob" }
 env_logger = { version = "0.7.1", default-features = false, features = ["humantime"] }
+ra_cargo_watch = { path = "../ra_cargo_watch" }
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index eeca67ee1..0dee1f6fe 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -3,7 +3,7 @@
 use lsp_types::{
    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
    DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
-    ImplementationProviderCapability, RenameOptions, RenameProviderCapability,
+    ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
    SelectionRangeProviderCapability, ServerCapabilities, SignatureHelpOptions,
    TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
    TypeDefinitionProviderCapability, WorkDoneProgressOptions,
@@ -16,7 +16,7 @@ pub fn server_capabilities() -> ServerCapabilities {
            change: Some(TextDocumentSyncKind::Full),
            will_save: None,
            will_save_wait_until: None,
-            save: None,
+            save: Some(SaveOptions::default()),
        })),
        hover_provider: Some(true),
        completion_provider: Some(CompletionOptions {
@@ -46,6 +46,7 @@ pub fn server_capabilities() -> ServerCapabilities {
            more_trigger_character: Some(vec![".".to_string(), ">".to_string()]),
        }),
        selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
+        semantic_highlighting: None,
        folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
        rename_provider: Some(RenameProviderCapability::Options(RenameOptions {
            prepare_provider: Some(true),
diff --git a/crates/ra_lsp_server/src/config.rs b/crates/ra_lsp_server/src/config.rs
index 67942aa41..2d7948d74 100644
--- a/crates/ra_lsp_server/src/config.rs
+++ b/crates/ra_lsp_server/src/config.rs
@@ -32,6 +32,11 @@ pub struct ServerConfig {
    pub max_inlay_hint_length: Option<usize>,
+    pub cargo_watch_enable: bool,
+    pub cargo_watch_args: Vec<String>,
+    pub cargo_watch_command: String,
+    pub cargo_watch_all_targets: bool,
    /// For internal usage to make integrated tests faster.
    #[serde(deserialize_with = "nullable_bool_true")]
    pub with_sysroot: bool,
@@ -51,6 +56,10 @@ impl Default for ServerConfig {
            use_client_watching: false,
            lru_capacity: None,
            max_inlay_hint_length: None,
+            cargo_watch_enable: true,
+            cargo_watch_args: Vec::new(),
+            cargo_watch_command: "check".to_string(),
+            cargo_watch_all_targets: true,
            with_sysroot: true,
            feature_flags: FxHashMap::default(),
            cargo_features: Default::default(),
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index dda318e43..af1a487de 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -10,6 +10,7 @@ use std::{error::Error, fmt, panic, path::PathBuf, sync::Arc, time::Instant};
 use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{ClientCapabilities, NumberOrString};
+use ra_cargo_watch::{CheckOptions, CheckTask};
 use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsTask, Watch};
@@ -126,6 +127,12 @@ pub fn main_loop(
                    .and_then(|it| it.line_folding_only)
                    .unwrap_or(false),
                max_inlay_hint_length: config.max_inlay_hint_length,
+                cargo_watch: CheckOptions {
+                    enable: config.cargo_watch_enable,
+                    args: config.cargo_watch_args,
+                    command: config.cargo_watch_command,
+                    all_targets: config.cargo_watch_all_targets,
+                },
            }
        };
@@ -176,7 +183,11 @@ pub fn main_loop(
                    Ok(task) => Event::Vfs(task),
                    Err(RecvError) => Err("vfs died")?,
                },
-                recv(libdata_receiver) -> data => Event::Lib(data.unwrap())
+                recv(libdata_receiver) -> data => Event::Lib(data.unwrap()),
+                recv(world_state.check_watcher.task_recv) -> task => match task {
+                    Ok(task) => Event::CheckWatcher(task),
+                    Err(RecvError) => Err("check watcher died")?,
+                }
            };
            if let Event::Msg(Message::Request(req)) = &event {
                if connection.handle_shutdown(&req)? {
@@ -222,6 +233,7 @@ enum Event {
    Task(Task),
    Vfs(VfsTask),
    Lib(LibraryData),
+    CheckWatcher(CheckTask),
 }
 impl fmt::Debug for Event {
@@ -259,6 +271,7 @@ impl fmt::Debug for Event {
            Event::Task(it) => fmt::Debug::fmt(it, f),
            Event::Vfs(it) => fmt::Debug::fmt(it, f),
            Event::Lib(it) => fmt::Debug::fmt(it, f),
+            Event::CheckWatcher(it) => fmt::Debug::fmt(it, f),
        }
    }
 }
@@ -318,6 +331,28 @@ fn loop_turn(
            world_state.maybe_collect_garbage();
            loop_state.in_flight_libraries -= 1;
        }
+        Event::CheckWatcher(task) => match task {
+            CheckTask::Update(uri) => {
+                // We manually send a diagnostic update when the watcher asks
+                // us to, to avoid the issue of having to change the file to
+                // receive updated diagnostics.
+                let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
+                if let Some(file_id) = world_state.vfs.read().path2file(&path) {
+                    let params =
+                        handlers::publish_diagnostics(&world_state.snapshot(), FileId(file_id.0))?;
+                    let not = notification_new::<req::PublishDiagnostics>(params);
+                    task_sender.send(Task::Notify(not)).unwrap();
+                }
+            }
+            CheckTask::Status(progress) => {
+                let params = req::ProgressParams {
+                    token: req::ProgressToken::String("rustAnalyzer/cargoWatcher".to_string()),
+                    value: req::ProgressParamsValue::WorkDone(progress),
+                };
+                let not = notification_new::<req::Progress>(params);
+                task_sender.send(Task::Notify(not)).unwrap();
+            }
+        },
        Event::Msg(msg) => match msg {
            Message::Request(req) => on_request(
                world_state,
@@ -517,6 +552,13 @@ fn on_notification(
        }
        Err(not) => not,
    };
+    let not = match notification_cast::<req::DidSaveTextDocument>(not) {
+        Ok(_params) => {
+            state.check_watcher.update();
+            return Ok(());
+        }
+        Err(not) => not,
+    };
    let not = match notification_cast::<req::DidCloseTextDocument>(not) {
        Ok(params) => {
            let uri = params.text_document.uri;
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 39eb3df3e..331beab13 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -654,6 +654,29 @@ pub fn handle_code_action(
        res.push(action.into());
    }
+    for fix in world.check_watcher.read().fixes_for(&params.text_document.uri).into_iter().flatten()
+    {
+        let fix_range = fix.location.range.conv_with(&line_index);
+        if fix_range.intersection(&range).is_none() {
+            continue;
+        }
+        let edits = vec![TextEdit::new(fix.location.range, fix.replacement.clone())];
+        let mut edit_map = std::collections::HashMap::new();
+        edit_map.insert(fix.location.uri.clone(), edits);
+        let edit = WorkspaceEdit::new(edit_map);
+        let action = CodeAction {
+            title: fix.title.clone(),
+            kind: Some("quickfix".to_string()),
+            diagnostics: Some(fix.diagnostics.clone()),
+            edit: Some(edit),
+            command: None,
+            is_preferred: None,
+        };
+        res.push(action.into());
+    }
    for assist in assists {
        let title = assist.change.label.clone();
        let edit = assist.change.try_conv_with(&world)?;
@@ -820,7 +843,7 @@ pub fn publish_diagnostics(
    let _p = profile("publish_diagnostics");
    let uri = world.file_id_to_uri(file_id)?;
    let line_index = world.analysis().file_line_index(file_id)?;
-    let diagnostics = world
+    let mut diagnostics: Vec<Diagnostic> = world
        .analysis()
        .diagnostics(file_id)?
        .into_iter()
@@ -834,6 +857,9 @@ pub fn publish_diagnostics(
            tags: None,
        })
        .collect();
+    if let Some(check_diags) = world.check_watcher.read().diagnostics_for(&uri) {
+        diagnostics.extend(check_diags.iter().cloned());
+    }
    Ok(req::PublishDiagnosticsParams { uri, diagnostics, version: None })
 }
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index b34e6f9b8..40edaf677 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -9,10 +9,10 @@ pub use lsp_types::{
    CodeLensParams, CompletionParams, CompletionResponse, DidChangeConfigurationParams,
    DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions,
    DocumentOnTypeFormattingParams, DocumentSymbolParams, DocumentSymbolResponse,
-    FileSystemWatcher, Hover, InitializeResult, MessageType, PublishDiagnosticsParams,
+    FileSystemWatcher, Hover, InitializeResult, MessageType, ProgressParams, ProgressParamsValue,
-    ReferenceParams, Registration, RegistrationParams, SelectionRange, SelectionRangeParams,
+    ProgressToken, PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams,
-    ShowMessageParams, SignatureHelp, TextDocumentEdit, TextDocumentPositionParams, TextEdit,
+    SelectionRange, SelectionRangeParams, ShowMessageParams, SignatureHelp, TextDocumentEdit,
-    WorkspaceEdit, WorkspaceSymbolParams,
+    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams,
 };
 pub enum AnalyzerStatus {}
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 79431e7e6..4b3959e38 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -12,6 +12,7 @@ use crossbeam_channel::{unbounded, Receiver};
 use lsp_server::ErrorCode;
 use lsp_types::Url;
 use parking_lot::RwLock;
+use ra_cargo_watch::{CheckOptions, CheckWatcher, CheckWatcherSharedState};
 use ra_ide::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FeatureFlags, FileId, LibraryData,
    SourceRootId,
@@ -34,6 +35,7 @@ pub struct Options {
    pub supports_location_link: bool,
    pub line_folding_only: bool,
    pub max_inlay_hint_length: Option<usize>,
+    pub cargo_watch: CheckOptions,
 }
 /// `WorldState` is the primary mutable state of the language server
@@ -52,6 +54,7 @@ pub struct WorldState {
    pub vfs: Arc<RwLock<Vfs>>,
    pub task_receiver: Receiver<VfsTask>,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
+    pub check_watcher: CheckWatcher,
 }
 /// An immutable snapshot of the world's state at a point in time.
@@ -61,6 +64,7 @@ pub struct WorldSnapshot {
    pub analysis: Analysis,
    pub vfs: Arc<RwLock<Vfs>>,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
+    pub check_watcher: Arc<RwLock<CheckWatcherSharedState>>,
 }
 impl WorldState {
@@ -127,6 +131,10 @@ impl WorldState {
        }
        change.set_crate_graph(crate_graph);
+        // FIXME: Figure out the multi-workspace situation
+        let check_watcher =
+            CheckWatcher::new(&options.cargo_watch, folder_roots.first().cloned().unwrap());
        let mut analysis_host = AnalysisHost::new(lru_capacity, feature_flags);
        analysis_host.apply_change(change);
        WorldState {
@@ -138,6 +146,7 @@ impl WorldState {
            vfs: Arc::new(RwLock::new(vfs)),
            task_receiver,
            latest_requests: Default::default(),
+            check_watcher,
        }
    }
@@ -199,6 +208,7 @@ impl WorldState {
            analysis: self.analysis_host.analysis(),
            vfs: Arc::clone(&self.vfs),
            latest_requests: Arc::clone(&self.latest_requests),
+            check_watcher: self.check_watcher.shared.clone(),
        }
    }
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index c862d3912..1b3c246c7 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -165,7 +165,7 @@ impl CargoWorkspace {
            // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
            // https://github.com/oli-obk/cargo_metadata/issues/79
            meta.features(CargoOpt::NoDefaultFeatures);
-        } else {
+        } else if cargo_features.features.len() > 0 {
            meta.features(CargoOpt::SomeFeatures(cargo_features.features.clone()));
        }
        if let Some(parent) = cargo_toml.parent() {
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 277532a8c..89cb9a9f3 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -17,7 +17,9 @@ use crate::{
 pub use self::{
    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp},
-    extensions::{FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind},
+    extensions::{
+        FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind, VisibilityKind,
+    },
    generated::*,
    tokens::*,
    traits::*,
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index a8f625176..d9666cdca 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -221,6 +221,10 @@ impl ast::FnDef {
            .and_then(|it| it.into_token())
            .filter(|it| it.kind() == T![;])
    }
+    pub fn is_async(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == T![async])
+    }
 }
 impl ast::LetStmt {
@@ -409,3 +413,32 @@ impl ast::TraitDef {
        self.syntax().children_with_tokens().any(|t| t.kind() == T![auto])
    }
 }
+pub enum VisibilityKind {
+    In(ast::Path),
+    PubCrate,
+    PubSuper,
+    Pub,
+}
+impl ast::Visibility {
+    pub fn kind(&self) -> VisibilityKind {
+        if let Some(path) = children(self).next() {
+            VisibilityKind::In(path)
+        } else if self.is_pub_crate() {
+            VisibilityKind::PubCrate
+        } else if self.is_pub_super() {
+            VisibilityKind::PubSuper
+        } else {
+            VisibilityKind::Pub
+        }
+    }
+    fn is_pub_crate(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == T![crate])
+    }
+    fn is_pub_super(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == T![super])
+    }
+}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 9f9d6e63c..e64c83d33 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1064,6 +1064,7 @@ impl AstNode for ExternCrateItem {
    }
 }
 impl ast::AttrsOwner for ExternCrateItem {}
+impl ast::VisibilityOwner for ExternCrateItem {}
 impl ExternCrateItem {
    pub fn name_ref(&self) -> Option<NameRef> {
        AstChildren::new(&self.syntax).next()
@@ -2006,6 +2007,7 @@ impl AstNode for ModuleItem {
    }
 }
 impl ast::AttrsOwner for ModuleItem {}
+impl ast::VisibilityOwner for ModuleItem {}
 impl ModuleItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Name {
@@ -3893,6 +3895,7 @@ impl AstNode for UseItem {
    }
 }
 impl ast::AttrsOwner for UseItem {}
+impl ast::VisibilityOwner for UseItem {}
 impl UseItem {
    pub fn use_tree(&self) -> Option<UseTree> {
        AstChildren::new(&self.syntax).next()
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 08aafb610..e43a724f0 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -412,7 +412,7 @@ Grammar(
        "ModuleItem": (
            enum: ["StructDef", "UnionDef", "EnumDef", "FnDef", "TraitDef", "TypeAliasDef", "ImplBlock",
                   "UseItem", "ExternCrateItem", "ConstDef", "StaticDef", "Module" ],
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
        ),
        "ImplItem": (
            enum: ["FnDef", "TypeAliasDef", "ConstDef"],
@@ -683,7 +683,7 @@ Grammar(
            ]
        ),
        "UseItem": (
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
            options: [ "UseTree" ],
        ),
        "UseTree": (
@@ -696,7 +696,7 @@ Grammar(
            collections: [("use_trees", "UseTree")]
        ),
        "ExternCrateItem": (
-            traits: ["AttrsOwner"],
+            traits: ["AttrsOwner", "VisibilityOwner"],
            options: ["NameRef", "Alias"],
        ),
        "ArgList": (
diff --git a/docs/user/assists.md b/docs/user/assists.md
index 334ba450f..ecf206f71 100644
--- a/docs/user/assists.md
+++ b/docs/user/assists.md
@@ -98,26 +98,26 @@ Adds scaffold for overriding default impl members.
 ```rust
 // BEFORE
-trait T {
+trait Trait {
    Type X;
    fn foo(&self);
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait for () {
    Type X = ();
    fn foo(&self) {}┃
 }
 // AFTER
-trait T {
+trait Trait {
    Type X;
    fn foo(&self);
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait for () {
    Type X = ();
    fn foo(&self) {}
    fn bar(&self) {}
@@ -131,25 +131,25 @@ Adds scaffold for required impl members.
 ```rust
 // BEFORE
-trait T {
+trait Trait<T> {
    Type X;
-    fn foo(&self);
+    fn foo(&self) -> T;
    fn bar(&self) {}
 }
-impl T for () {┃
+impl Trait<u32> for () {┃
 }
 // AFTER
-trait T {
+trait Trait<T> {
    Type X;
-    fn foo(&self);
+    fn foo(&self) -> T;
    fn bar(&self) {}
 }
-impl T for () {
+impl Trait<u32> for () {
-    fn foo(&self) { unimplemented!() }
+    fn foo(&self) -> u32 { unimplemented!() }
 }
 ```
diff --git a/editors/code/package.json b/editors/code/package.json
index 8e7046418..f28ce1772 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -18,7 +18,7 @@
    "scripts": {
        "vscode:prepublish": "npm run compile",
        "package": "vsce package",
-        "compile": "rollup -c && shx cp src/utils/terminateProcess.sh bundle/terminateProcess.sh",
+        "compile": "rollup -c",
        "watch": "tsc -watch -p ./",
        "fix": "prettier **/*.{json,ts} --write && tslint --project . --fix",
        "lint": "tslint --project .",
@@ -134,16 +134,6 @@
                "command": "rust-analyzer.reload",
                "title": "Restart server",
                "category": "Rust Analyzer"
-            },
-            {
-                "command": "rust-analyzer.startCargoWatch",
-                "title": "Start Cargo Watch",
-                "category": "Rust Analyzer"
-            },
-            {
-                "command": "rust-analyzer.stopCargoWatch",
-                "title": "Stop Cargo Watch",
-                "category": "Rust Analyzer"
            }
        ],
        "keybindings": [
@@ -261,21 +251,6 @@
                    "default": "ra_lsp_server",
                    "description": "Path to ra_lsp_server executable"
                },
-                "rust-analyzer.enableCargoWatchOnStartup": {
-                    "type": "string",
-                    "default": "ask",
-                    "enum": [
-                        "ask",
-                        "enabled",
-                        "disabled"
-                    ],
-                    "enumDescriptions": [
-                        "Asks each time whether to run `cargo watch`",
-                        "`cargo watch` is always started",
-                        "Don't start `cargo watch`"
-                    ],
-                    "description": "Whether to run `cargo watch` on startup"
-                },
                "rust-analyzer.excludeGlobs": {
                    "type": "array",
                    "default": [],
@@ -286,21 +261,21 @@
                    "default": true,
                    "description": "client provided file watching instead of notify watching."
                },
+                "rust-analyzer.cargo-watch.enable": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Run `cargo check` for diagnostics on save"
+                },
                "rust-analyzer.cargo-watch.arguments": {
-                    "type": "string",
+                    "type": "array",
                    "description": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
-                    "default": ""
+                    "default": []
                },
                "rust-analyzer.cargo-watch.command": {
                    "type": "string",
                    "description": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
                    "default": "check"
                },
-                "rust-analyzer.cargo-watch.ignore": {
-                    "type": "array",
-                    "description": "A list of patterns for cargo-watch to ignore (will be passed as `--ignore`)",
-                    "default": []
-                },
                "rust-analyzer.cargo-watch.allTargets": {
                    "type": "boolean",
                    "description": "Check all targets and tests (will be passed as `--all-targets`)",
@@ -322,17 +297,6 @@
                    "default": "off",
                    "description": "Trace requests to the ra_lsp_server"
                },
-                "rust-analyzer.trace.cargo-watch": {
-                    "type": "string",
-                    "scope": "window",
-                    "enum": [
-                        "off",
-                        "error",
-                        "verbose"
-                    ],
-                    "default": "off",
-                    "description": "Trace output of cargo-watch"
-                },
                "rust-analyzer.lruCapacity": {
                    "type": "number",
                    "default": null,
diff --git a/editors/code/src/commands/cargo_watch.ts b/editors/code/src/commands/cargo_watch.ts
deleted file mode 100644
index ac62bdd48..000000000
--- a/editors/code/src/commands/cargo_watch.ts
+++ /dev/null
@@ -1,264 +0,0 @@
-import * as child_process from 'child_process';
-import * as path from 'path';
-import * as vscode from 'vscode';
-import { Server } from '../server';
-import { terminate } from '../utils/processes';
-import { LineBuffer } from './line_buffer';
-import { StatusDisplay } from './watch_status';
-import {
-    mapRustDiagnosticToVsCode,
-    RustDiagnostic,
-} from '../utils/diagnostics/rust';
-import SuggestedFixCollection from '../utils/diagnostics/SuggestedFixCollection';
-import { areDiagnosticsEqual } from '../utils/diagnostics/vscode';
-export async function registerCargoWatchProvider(
-    subscriptions: vscode.Disposable[],
-): Promise<CargoWatchProvider | undefined> {
-    let cargoExists = false;
-    // Check if the working directory is valid cargo root path
-    const cargoTomlPath = path.join(vscode.workspace.rootPath!, 'Cargo.toml');
-    const cargoTomlUri = vscode.Uri.file(cargoTomlPath);
-    const cargoTomlFileInfo = await vscode.workspace.fs.stat(cargoTomlUri);
-    if (cargoTomlFileInfo) {
-        cargoExists = true;
-    }
-    if (!cargoExists) {
-        vscode.window.showErrorMessage(
-            `Couldn\'t find \'Cargo.toml\' at ${cargoTomlPath}`,
-        );
-        return;
-    }
-    const provider = new CargoWatchProvider();
-    subscriptions.push(provider);
-    return provider;
-}
-export class CargoWatchProvider implements vscode.Disposable {
-    private readonly diagnosticCollection: vscode.DiagnosticCollection;
-    private readonly statusDisplay: StatusDisplay;
-    private readonly outputChannel: vscode.OutputChannel;
-    private suggestedFixCollection: SuggestedFixCollection;
-    private codeActionDispose: vscode.Disposable;
-    private cargoProcess?: child_process.ChildProcess;
-    constructor() {
-        this.diagnosticCollection = vscode.languages.createDiagnosticCollection(
-            'rustc',
-        );
-        this.statusDisplay = new StatusDisplay(
-            Server.config.cargoWatchOptions.command,
-        );
-        this.outputChannel = vscode.window.createOutputChannel(
-            'Cargo Watch Trace',
-        );
-        // Track `rustc`'s suggested fixes so we can convert them to code actions
-        this.suggestedFixCollection = new SuggestedFixCollection();
-        this.codeActionDispose = vscode.languages.registerCodeActionsProvider(
-            [{ scheme: 'file', language: 'rust' }],
-            this.suggestedFixCollection,
-            {
-                providedCodeActionKinds:
-                    SuggestedFixCollection.PROVIDED_CODE_ACTION_KINDS,
-            },
-        );
-    }
-    public start() {
-        if (this.cargoProcess) {
-            vscode.window.showInformationMessage(
-                'Cargo Watch is already running',
-            );
-            return;
-        }
-        let args =
-            Server.config.cargoWatchOptions.command + ' --message-format json';
-        if (Server.config.cargoWatchOptions.allTargets) {
-            args += ' --all-targets';
-        }
-        if (Server.config.cargoWatchOptions.command.length > 0) {
-            // Excape the double quote string:
-            args += ' ' + Server.config.cargoWatchOptions.arguments;
-        }
-        // Windows handles arguments differently than the unix-likes, so we need to wrap the args in double quotes
-        if (process.platform === 'win32') {
-            args = '"' + args + '"';
-        }
-        const ignoreFlags = Server.config.cargoWatchOptions.ignore.reduce(
-            (flags, pattern) => [...flags, '--ignore', pattern],
-            [] as string[],
-        );
-        // Start the cargo watch with json message
-        this.cargoProcess = child_process.spawn(
-            'cargo',
-            ['watch', '-x', args, ...ignoreFlags],
-            {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                cwd: vscode.workspace.rootPath,
-                windowsVerbatimArguments: true,
-            },
-        );
-        if (!this.cargoProcess) {
-            vscode.window.showErrorMessage('Cargo Watch failed to start');
-            return;
-        }
-        const stdoutData = new LineBuffer();
-        this.cargoProcess.stdout?.on('data', (s: string) => {
-            stdoutData.processOutput(s, line => {
-                this.logInfo(line);
-                try {
-                    this.parseLine(line);
-                } catch (err) {
-                    this.logError(`Failed to parse: ${err}, content : ${line}`);
-                }
-            });
-        });
-        const stderrData = new LineBuffer();
-        this.cargoProcess.stderr?.on('data', (s: string) => {
-            stderrData.processOutput(s, line => {
-                this.logError('Error on cargo-watch : {\n' + line + '}\n');
-            });
-        });
-        this.cargoProcess.on('error', (err: Error) => {
-            this.logError(
-                'Error on cargo-watch process : {\n' + err.message + '}\n',
-            );
-        });
-        this.logInfo('cargo-watch started.');
-    }
-    public stop() {
-        if (this.cargoProcess) {
-            this.cargoProcess.kill();
-            terminate(this.cargoProcess);
-            this.cargoProcess = undefined;
-        } else {
-            vscode.window.showInformationMessage('Cargo Watch is not running');
-        }
-    }
-    public dispose(): void {
-        this.stop();
-        this.diagnosticCollection.clear();
-        this.diagnosticCollection.dispose();
-        this.outputChannel.dispose();
-        this.statusDisplay.dispose();
-        this.codeActionDispose.dispose();
-    }
-    private logInfo(line: string) {
-        if (Server.config.cargoWatchOptions.trace === 'verbose') {
-            this.outputChannel.append(line);
-        }
-    }
-    private logError(line: string) {
-        if (
-            Server.config.cargoWatchOptions.trace === 'error' ||
-            Server.config.cargoWatchOptions.trace === 'verbose'
-        ) {
-            this.outputChannel.append(line);
-        }
-    }
-    private parseLine(line: string) {
-        if (line.startsWith('[Running')) {
-            this.diagnosticCollection.clear();
-            this.suggestedFixCollection.clear();
-            this.statusDisplay.show();
-        }
-        if (line.startsWith('[Finished running')) {
-            this.statusDisplay.hide();
-        }
-        interface CargoArtifact {
-            reason: string;
-            package_id: string;
-        }
-        // https://github.com/rust-lang/cargo/blob/master/src/cargo/util/machine_message.rs
-        interface CargoMessage {
-            reason: string;
-            package_id: string;
-            message: RustDiagnostic;
-        }
-        // cargo-watch itself output non json format
-        // Ignore these lines
-        let data: CargoMessage;
-        try {
-            data = JSON.parse(line.trim());
-        } catch (error) {
-            this.logError(`Fail to parse to json : { ${error} }`);
-            return;
-        }
-        if (data.reason === 'compiler-artifact') {
-            const msg = data as CargoArtifact;
-            // The format of the package_id is "{name} {version} ({source_id})",
-            // https://github.com/rust-lang/cargo/blob/37ad03f86e895bb80b474c1c088322634f4725f5/src/cargo/core/package_id.rs#L53
-            this.statusDisplay.packageName = msg.package_id.split(' ')[0];
-        } else if (data.reason === 'compiler-message') {
-            const msg = data.message as RustDiagnostic;
-            const mapResult = mapRustDiagnosticToVsCode(msg);
-            if (!mapResult) {
-                return;
-            }
-            const { location, diagnostic, suggestedFixes } = mapResult;
-            const fileUri = location.uri;
-            const diagnostics: vscode.Diagnostic[] = [
-                ...(this.diagnosticCollection!.get(fileUri) || []),
-            ];
-            // If we're building multiple targets it's possible we've already seen this diagnostic
-            const isDuplicate = diagnostics.some(d =>
-                areDiagnosticsEqual(d, diagnostic),
-            );
-            if (isDuplicate) {
-                return;
-            }
-            diagnostics.push(diagnostic);
-            this.diagnosticCollection!.set(fileUri, diagnostics);
-            if (suggestedFixes.length) {
-                for (const suggestedFix of suggestedFixes) {
-                    this.suggestedFixCollection.addSuggestedFixForDiagnostic(
-                        suggestedFix,
-                        diagnostic,
-                    );
-                }
-                // Have VsCode query us for the code actions
-                vscode.commands.executeCommand(
-                    'vscode.executeCodeActionProvider',
-                    fileUri,
-                    diagnostic.range,
-                );
-            }
-        }
-    }
-}
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index cf980e257..7728541de 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,11 +1,7 @@
-import * as child_process from 'child_process';
-import * as util from 'util';
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import { Server } from '../server';
-import { CargoWatchProvider, registerCargoWatchProvider } from './cargo_watch';
 interface RunnablesParams {
    textDocument: lc.TextDocumentIdentifier;
@@ -131,90 +127,3 @@ export async function handleSingle(runnable: Runnable) {
    return vscode.tasks.executeTask(task);
 }
-/**
- * Interactively asks the user whether we should run `cargo check` in order to
- * provide inline diagnostics; the user is met with a series of dialog boxes
- * that, when accepted, allow us to `cargo install cargo-watch` and then run it.
- */
-export async function interactivelyStartCargoWatch(
-    context: vscode.ExtensionContext,
-): Promise<CargoWatchProvider | undefined> {
-    if (Server.config.cargoWatchOptions.enableOnStartup === 'disabled') {
-        return;
-    }
-    if (Server.config.cargoWatchOptions.enableOnStartup === 'ask') {
-        const watch = await vscode.window.showInformationMessage(
-            'Start watching changes with cargo? (Executes `cargo watch`, provides inline diagnostics)',
-            'yes',
-            'no',
-        );
-        if (watch !== 'yes') {
-            return;
-        }
-    }
-    return startCargoWatch(context);
-}
-export async function startCargoWatch(
-    context: vscode.ExtensionContext,
-): Promise<CargoWatchProvider | undefined> {
-    const execPromise = util.promisify(child_process.exec);
-    const { stderr, code = 0 } = await execPromise(
-        'cargo watch --version',
-    ).catch(e => e);
-    if (stderr.includes('no such subcommand: `watch`')) {
-        const msg =
-            'The `cargo-watch` subcommand is not installed. Install? (takes ~1-2 minutes)';
-        const install = await vscode.window.showInformationMessage(
-            msg,
-            'yes',
-            'no',
-        );
-        if (install !== 'yes') {
-            return;
-        }
-        const label = 'install-cargo-watch';
-        const taskFinished = new Promise((resolve, _reject) => {
-            const disposable = vscode.tasks.onDidEndTask(({ execution }) => {
-                if (execution.task.name === label) {
-                    disposable.dispose();
-                    resolve();
-                }
-            });
-        });
-        vscode.tasks.executeTask(
-            createTask({
-                label,
-                bin: 'cargo',
-                args: ['install', 'cargo-watch'],
-                env: {},
-            }),
-        );
-        await taskFinished;
-        const output = await execPromise('cargo watch --version').catch(e => e);
-        if (output.stderr !== '') {
-            vscode.window.showErrorMessage(
-                `Couldn't install \`cargo-\`watch: ${output.stderr}`,
-            );
-            return;
-        }
-    } else if (code !== 0) {
-        vscode.window.showErrorMessage(
-            `\`cargo watch\` failed with ${code}: ${stderr}`,
-        );
-        return;
-    }
-    const provider = await registerCargoWatchProvider(context.subscriptions);
-    if (provider) {
-        provider.start();
-    }
-    return provider;
-}
diff --git a/editors/code/src/commands/watch_status.ts b/editors/code/src/commands/watch_status.ts
index 8d64394c7..10787b510 100644
--- a/editors/code/src/commands/watch_status.ts
+++ b/editors/code/src/commands/watch_status.ts
@@ -57,7 +57,49 @@ export class StatusDisplay implements vscode.Disposable {
        this.statusBarItem.dispose();
    }
+    public handleProgressNotification(params: ProgressParams) {
+        const { token, value } = params;
+        if (token !== 'rustAnalyzer/cargoWatcher') {
+            return;
+        }
+        switch (value.kind) {
+            case 'begin':
+                this.show();
+                break;
+            case 'report':
+                if (value.message) {
+                    this.packageName = value.message;
+                }
+                break;
+            case 'end':
+                this.hide();
+                break;
+        }
+    }
    private frame() {
        return spinnerFrames[(this.i = ++this.i % spinnerFrames.length)];
    }
 }
+// FIXME: Replace this once vscode-languageclient is updated to LSP 3.15
+interface ProgressParams {
+    token: string;
+    value: WorkDoneProgress;
+}
+enum WorkDoneProgressKind {
+    Begin = 'begin',
+    Report = 'report',
+    End = 'end',
+}
+interface WorkDoneProgress {
+    kind: WorkDoneProgressKind;
+    message?: string;
+    cancelable?: boolean;
+    percentage?: string;
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index c06dddb1c..a88be6e35 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -5,15 +5,10 @@ import { Server } from './server';
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
-export type CargoWatchStartupOptions = 'ask' | 'enabled' | 'disabled';
-export type CargoWatchTraceOptions = 'off' | 'error' | 'verbose';
 export interface CargoWatchOptions {
-    enableOnStartup: CargoWatchStartupOptions;
+    enable: boolean;
-    arguments: string;
+    arguments: string[];
    command: string;
-    trace: CargoWatchTraceOptions;
-    ignore: string[];
    allTargets: boolean;
 }
@@ -37,11 +32,9 @@ export class Config {
    // for internal use
    public withSysroot: null | boolean = null;
    public cargoWatchOptions: CargoWatchOptions = {
-        enableOnStartup: 'ask',
+        enable: true,
-        trace: 'off',
+        arguments: [],
-        arguments: '',
        command: '',
-        ignore: [],
        allTargets: true,
    };
    public cargoFeatures: CargoFeatures = {
@@ -104,23 +97,17 @@ export class Config {
                RA_LSP_DEBUG || (config.get('raLspServerPath') as string);
        }
-        if (config.has('enableCargoWatchOnStartup')) {
+        if (config.has('cargo-watch.enable')) {
-            this.cargoWatchOptions.enableOnStartup = config.get<
+            this.cargoWatchOptions.enable = config.get<boolean>(
-                CargoWatchStartupOptions
+                'cargo-watch.enable',
-            >('enableCargoWatchOnStartup', 'ask');
+                true,
-        }
-        if (config.has('trace.cargo-watch')) {
-            this.cargoWatchOptions.trace = config.get<CargoWatchTraceOptions>(
-                'trace.cargo-watch',
-                'off',
            );
        }
        if (config.has('cargo-watch.arguments')) {
-            this.cargoWatchOptions.arguments = config.get<string>(
+            this.cargoWatchOptions.arguments = config.get<string[]>(
                'cargo-watch.arguments',
-                '',
+                [],
            );
        }
@@ -131,13 +118,6 @@ export class Config {
            );
        }
-        if (config.has('cargo-watch.ignore')) {
-            this.cargoWatchOptions.ignore = config.get<string[]>(
-                'cargo-watch.ignore',
-                [],
-            );
-        }
        if (config.has('cargo-watch.allTargets')) {
            this.cargoWatchOptions.allTargets = config.get<boolean>(
                'cargo-watch.allTargets',
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index 815f3692c..1da10ebd0 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -2,14 +2,10 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import * as commands from './commands';
-import { CargoWatchProvider } from './commands/cargo_watch';
 import { ExpandMacroContentProvider } from './commands/expand_macro';
 import { HintsUpdater } from './commands/inlay_hints';
-import {
-    interactivelyStartCargoWatch,
-    startCargoWatch,
-} from './commands/runnables';
 import { SyntaxTreeContentProvider } from './commands/syntaxTree';
+import { StatusDisplay } from './commands/watch_status';
 import * as events from './events';
 import * as notifications from './notifications';
 import { Server } from './server';
@@ -88,6 +84,11 @@ export async function activate(context: vscode.ExtensionContext) {
        overrideCommand('type', commands.onEnter.handle);
    }
+    const watchStatus = new StatusDisplay(
+        Server.config.cargoWatchOptions.command,
+    );
+    disposeOnDeactivation(watchStatus);
    // Notifications are events triggered by the language server
    const allNotifications: Iterable<[
        string,
@@ -97,6 +98,10 @@ export async function activate(context: vscode.ExtensionContext) {
            'rust-analyzer/publishDecorations',
            notifications.publishDecorations.handle,
        ],
+        [
+            '$/progress',
+            params => watchStatus.handleProgressNotification(params),
+        ],
    ];
    const syntaxTreeContentProvider = new SyntaxTreeContentProvider();
    const expandMacroContentProvider = new ExpandMacroContentProvider();
@@ -139,26 +144,6 @@ export async function activate(context: vscode.ExtensionContext) {
    vscode.commands.registerCommand('rust-analyzer.reload', reloadCommand);
-    // Executing `cargo watch` provides us with inline diagnostics on save
-    let provider: CargoWatchProvider | undefined;
-    interactivelyStartCargoWatch(context).then(p => {
-        provider = p;
-    });
-    registerCommand('rust-analyzer.startCargoWatch', () => {
-        if (provider) {
-            provider.start();
-        } else {
-            startCargoWatch(context).then(p => {
-                provider = p;
-            });
-        }
-    });
-    registerCommand('rust-analyzer.stopCargoWatch', () => {
-        if (provider) {
-            provider.stop();
-        }
-    });
    // Start the language server, finally!
    try {
        await startServer();
diff --git a/editors/code/src/server.ts b/editors/code/src/server.ts
index 5ace1d0fa..ae81af848 100644
--- a/editors/code/src/server.ts
+++ b/editors/code/src/server.ts
@@ -55,6 +55,11 @@ export class Server {
                publishDecorations: true,
                lruCapacity: Server.config.lruCapacity,
                maxInlayHintLength: Server.config.maxInlayHintLength,
+                cargoWatchEnable: Server.config.cargoWatchOptions.enable,
+                cargoWatchArgumets: Server.config.cargoWatchOptions.arguments,
+                cargoWatchCommand: Server.config.cargoWatchOptions.command,
+                cargoWatchAllTargets:
+                    Server.config.cargoWatchOptions.allTargets,
                excludeGlobs: Server.config.excludeGlobs,
                useClientWatching: Server.config.useClientWatching,
                featureFlags: Server.config.featureFlags,
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/clippy/trivially_copy_pass_by_ref.json b/editors/code/src/test/fixtures/rust-diagnostics/clippy/trivially_copy_pass_by_ref.json
deleted file mode 100644
index d874e99bc..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/clippy/trivially_copy_pass_by_ref.json
+++ /dev/null
@@ -1,110 +0,0 @@
-{
-    "message": "this argument is passed by reference, but would be more efficient if passed by value",
-    "code": {
-        "code": "clippy::trivially_copy_pass_by_ref",
-        "explanation": null
-    },
-    "level": "warning",
-    "spans": [
-        {
-            "file_name": "compiler/mir/tagset.rs",
-            "byte_start": 941,
-            "byte_end": 946,
-            "line_start": 42,
-            "line_end": 42,
-            "column_start": 24,
-            "column_end": 29,
-            "is_primary": true,
-            "text": [
-                {
-                    "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
-                    "highlight_start": 24,
-                    "highlight_end": 29
-                }
-            ],
-            "label": null,
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        }
-    ],
-    "children": [
-        {
-            "message": "lint level defined here",
-            "code": null,
-            "level": "note",
-            "spans": [
-                {
-                    "file_name": "compiler/lib.rs",
-                    "byte_start": 8,
-                    "byte_end": 19,
-                    "line_start": 1,
-                    "line_end": 1,
-                    "column_start": 9,
-                    "column_end": 20,
-                    "is_primary": true,
-                    "text": [
-                        {
-                            "text": "#![warn(clippy::all)]",
-                            "highlight_start": 9,
-                            "highlight_end": 20
-                        }
-                    ],
-                    "label": null,
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "expansion": null
-                }
-            ],
-            "children": [],
-            "rendered": null
-        },
-        {
-            "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
-            "code": null,
-            "level": "note",
-            "spans": [],
-            "children": [],
-            "rendered": null
-        },
-        {
-            "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
-            "code": null,
-            "level": "help",
-            "spans": [],
-            "children": [],
-            "rendered": null
-        },
-        {
-            "message": "consider passing by value instead",
-            "code": null,
-            "level": "help",
-            "spans": [
-                {
-                    "file_name": "compiler/mir/tagset.rs",
-                    "byte_start": 941,
-                    "byte_end": 946,
-                    "line_start": 42,
-                    "line_end": 42,
-                    "column_start": 24,
-                    "column_end": 29,
-                    "is_primary": true,
-                    "text": [
-                        {
-                            "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
-                            "highlight_start": 24,
-                            "highlight_end": 29
-                        }
-                    ],
-                    "label": null,
-                    "suggested_replacement": "self",
-                    "suggestion_applicability": "Unspecified",
-                    "expansion": null
-                }
-            ],
-            "children": [],
-            "rendered": null
-        }
-    ],
-    "rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n  --> compiler/mir/tagset.rs:42:24\n   |\n42 |     pub fn is_disjoint(&self, other: Self) -> bool {\n   |                        ^^^^^ help: consider passing by value instead: `self`\n   |\nnote: lint level defined here\n  --> compiler/lib.rs:1:9\n   |\n1  | #![warn(clippy::all)]\n   |         ^^^^^^^^^^^\n   = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
-}
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/error/E0053.json b/editors/code/src/test/fixtures/rust-diagnostics/error/E0053.json
deleted file mode 100644
index ea5c976d1..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/error/E0053.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-    "message": "method `next` has an incompatible type for trait",
-    "code": {
-        "code": "E0053",
-        "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n    fn foo(x: u16);\n    fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n    // error, expected u16, found i16\n    fn foo(x: i16) { }\n\n    // error, types differ in mutability\n    fn bar(&mut self) { }\n}\n```\n"
-    },
-    "level": "error",
-    "spans": [
-        {
-            "file_name": "compiler/ty/list_iter.rs",
-            "byte_start": 1307,
-            "byte_end": 1350,
-            "line_start": 52,
-            "line_end": 52,
-            "column_start": 5,
-            "column_end": 48,
-            "is_primary": true,
-            "text": [
-                {
-                    "text": "    fn next(&self) -> Option<&'list ty::Ref<M>> {",
-                    "highlight_start": 5,
-                    "highlight_end": 48
-                }
-            ],
-            "label": "types differ in mutability",
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        }
-    ],
-    "children": [
-        {
-            "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
-            "code": null,
-            "level": "note",
-            "spans": [],
-            "children": [],
-            "rendered": null
-        }
-    ],
-    "rendered": "error[E0053]: method `next` has an incompatible type for trait\n  --> compiler/ty/list_iter.rs:52:5\n   |\n52 |     fn next(&self) -> Option<&'list ty::Ref<M>> {\n   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n   |\n   = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n              found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
-}
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/error/E0061.json b/editors/code/src/test/fixtures/rust-diagnostics/error/E0061.json
deleted file mode 100644
index 3154d1098..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/error/E0061.json
+++ /dev/null
@@ -1,114 +0,0 @@
-{
-    "message": "this function takes 2 parameters but 3 parameters were supplied",
-    "code": {
-        "code": "E0061",
-        "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
-    },
-    "level": "error",
-    "spans": [
-        {
-            "file_name": "compiler/ty/select.rs",
-            "byte_start": 8787,
-            "byte_end": 9241,
-            "line_start": 219,
-            "line_end": 231,
-            "column_start": 5,
-            "column_end": 6,
-            "is_primary": false,
-            "text": [
-                {
-                    "text": "    pub fn add_evidence(",
-                    "highlight_start": 5,
-                    "highlight_end": 25
-                },
-                {
-                    "text": "        &mut self,",
-                    "highlight_start": 1,
-                    "highlight_end": 19
-                },
-                {
-                    "text": "        target_poly: &ty::Ref<ty::Poly>,",
-                    "highlight_start": 1,
-                    "highlight_end": 41
-                },
-                {
-                    "text": "        evidence_poly: &ty::Ref<ty::Poly>,",
-                    "highlight_start": 1,
-                    "highlight_end": 43
-                },
-                {
-                    "text": "    ) {",
-                    "highlight_start": 1,
-                    "highlight_end": 8
-                },
-                {
-                    "text": "        match target_poly {",
-                    "highlight_start": 1,
-                    "highlight_end": 28
-                },
-                {
-                    "text": "            ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
-                    "highlight_start": 1,
-                    "highlight_end": 81
-                },
-                {
-                    "text": "            ty::Ref::Fixed(target_ty) => {",
-                    "highlight_start": 1,
-                    "highlight_end": 43
-                },
-                {
-                    "text": "                let evidence_ty = evidence_poly.resolve_to_ty();",
-                    "highlight_start": 1,
-                    "highlight_end": 65
-                },
-                {
-                    "text": "                self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
-                    "highlight_start": 1,
-                    "highlight_end": 76
-                },
-                {
-                    "text": "            }",
-                    "highlight_start": 1,
-                    "highlight_end": 14
-                },
-                {
-                    "text": "        }",
-                    "highlight_start": 1,
-                    "highlight_end": 10
-                },
-                {
-                    "text": "    }",
-                    "highlight_start": 1,
-                    "highlight_end": 6
-                }
-            ],
-            "label": "defined here",
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        },
-        {
-            "file_name": "compiler/ty/select.rs",
-            "byte_start": 4045,
-            "byte_end": 4057,
-            "line_start": 104,
-            "line_end": 104,
-            "column_start": 18,
-            "column_end": 30,
-            "is_primary": true,
-            "text": [
-                {
-                    "text": "            self.add_evidence(target_fixed, evidence_fixed, false);",
-                    "highlight_start": 18,
-                    "highlight_end": 30
-                }
-            ],
-            "label": "expected 2 parameters",
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        }
-    ],
-    "children": [],
-    "rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n   --> compiler/ty/select.rs:104:18\n    |\n104 |               self.add_evidence(target_fixed, evidence_fixed, false);\n    |                    ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | /     pub fn add_evidence(\n220 | |         &mut self,\n221 | |         target_poly: &ty::Ref<ty::Poly>,\n222 | |         evidence_poly: &ty::Ref<ty::Poly>,\n...   |\n230 | |         }\n231 | |     }\n    | |_____- defined here\n\n"
-}
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/error/E0277.json b/editors/code/src/test/fixtures/rust-diagnostics/error/E0277.json
deleted file mode 100644
index bfef33c7d..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/error/E0277.json
+++ /dev/null
@@ -1,261 +0,0 @@
-{
-    "rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n  |\n2 |     assert_eq!(1, \"love\");\n  |     ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n  |\n  = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
-    "children": [
-        {
-            "children": [],
-            "code": null,
-            "level": "help",
-            "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
-            "rendered": null,
-            "spans": []
-        }
-    ],
-    "code": {
-        "code": "E0277",
-        "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n    fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n    foo.bar();\n}\n\nfn main() {\n    // we now call the method with the i32 type, which doesn't implement\n    // the Foo trait\n    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n    fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n    foo.bar(); // we can now use this method since i32 implements the\n               // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n    fn bar(&self) {}\n}\n\nfn main() {\n    some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n    println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n                           //        implemented for the type `T`\n}\n\nfn main() {\n    // We now call the method with the i32 type,\n    // which *does* implement the Debug trait.\n    some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n    println!(\"{:?}\", foo);\n}\n\nfn main() {\n    // Calling the method is still fine, as i32 implements Debug.\n    some_func(5i32);\n\n    // This would fail to compile now:\n    // struct WithoutDebug;\n    // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
-    },
-    "level": "error",
-    "message": "can't compare `{integer}` with `&str`",
-    "spans": [
-        {
-            "byte_end": 155,
-            "byte_start": 153,
-            "column_end": 33,
-            "column_start": 31,
-            "expansion": {
-                "def_site_span": {
-                    "byte_end": 940,
-                    "byte_start": 0,
-                    "column_end": 6,
-                    "column_start": 1,
-                    "expansion": null,
-                    "file_name": "<::core::macros::assert_eq macros>",
-                    "is_primary": false,
-                    "label": null,
-                    "line_end": 36,
-                    "line_start": 1,
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "text": [
-                        {
-                            "highlight_end": 35,
-                            "highlight_start": 1,
-                            "text": "($ left : expr, $ right : expr) =>"
-                        },
-                        {
-                            "highlight_end": 3,
-                            "highlight_start": 1,
-                            "text": "({"
-                        },
-                        {
-                            "highlight_end": 33,
-                            "highlight_start": 1,
-                            "text": "     match (& $ left, & $ right)"
-                        },
-                        {
-                            "highlight_end": 7,
-                            "highlight_start": 1,
-                            "text": "     {"
-                        },
-                        {
-                            "highlight_end": 34,
-                            "highlight_start": 1,
-                            "text": "         (left_val, right_val) =>"
-                        },
-                        {
-                            "highlight_end": 11,
-                            "highlight_start": 1,
-                            "text": "         {"
-                        },
-                        {
-                            "highlight_end": 46,
-                            "highlight_start": 1,
-                            "text": "             if ! (* left_val == * right_val)"
-                        },
-                        {
-                            "highlight_end": 15,
-                            "highlight_start": 1,
-                            "text": "             {"
-                        },
-                        {
-                            "highlight_end": 25,
-                            "highlight_start": 1,
-                            "text": "                 panic !"
-                        },
-                        {
-                            "highlight_end": 57,
-                            "highlight_start": 1,
-                            "text": "                 (r#\"assertion failed: `(left == right)`"
-                        },
-                        {
-                            "highlight_end": 16,
-                            "highlight_start": 1,
-                            "text": "  left: `{:?}`,"
-                        },
-                        {
-                            "highlight_end": 18,
-                            "highlight_start": 1,
-                            "text": " right: `{:?}`\"#,"
-                        },
-                        {
-                            "highlight_end": 47,
-                            "highlight_start": 1,
-                            "text": "                  & * left_val, & * right_val)"
-                        },
-                        {
-                            "highlight_end": 15,
-                            "highlight_start": 1,
-                            "text": "             }"
-                        },
-                        {
-                            "highlight_end": 11,
-                            "highlight_start": 1,
-                            "text": "         }"
-                        },
-                        {
-                            "highlight_end": 7,
-                            "highlight_start": 1,
-                            "text": "     }"
-                        },
-                        {
-                            "highlight_end": 42,
-                            "highlight_start": 1,
-                            "text": " }) ; ($ left : expr, $ right : expr,) =>"
-                        },
-                        {
-                            "highlight_end": 49,
-                            "highlight_start": 1,
-                            "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
-                        },
-                        {
-                            "highlight_end": 53,
-                            "highlight_start": 1,
-                            "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
-                        },
-                        {
-                            "highlight_end": 3,
-                            "highlight_start": 1,
-                            "text": "({"
-                        },
-                        {
-                            "highlight_end": 37,
-                            "highlight_start": 1,
-                            "text": "     match (& ($ left), & ($ right))"
-                        },
-                        {
-                            "highlight_end": 7,
-                            "highlight_start": 1,
-                            "text": "     {"
-                        },
-                        {
-                            "highlight_end": 34,
-                            "highlight_start": 1,
-                            "text": "         (left_val, right_val) =>"
-                        },
-                        {
-                            "highlight_end": 11,
-                            "highlight_start": 1,
-                            "text": "         {"
-                        },
-                        {
-                            "highlight_end": 46,
-                            "highlight_start": 1,
-                            "text": "             if ! (* left_val == * right_val)"
-                        },
-                        {
-                            "highlight_end": 15,
-                            "highlight_start": 1,
-                            "text": "             {"
-                        },
-                        {
-                            "highlight_end": 25,
-                            "highlight_start": 1,
-                            "text": "                 panic !"
-                        },
-                        {
-                            "highlight_end": 57,
-                            "highlight_start": 1,
-                            "text": "                 (r#\"assertion failed: `(left == right)`"
-                        },
-                        {
-                            "highlight_end": 16,
-                            "highlight_start": 1,
-                            "text": "  left: `{:?}`,"
-                        },
-                        {
-                            "highlight_end": 22,
-                            "highlight_start": 1,
-                            "text": " right: `{:?}`: {}\"#,"
-                        },
-                        {
-                            "highlight_end": 72,
-                            "highlight_start": 1,
-                            "text": "                  & * left_val, & * right_val, $ crate :: format_args !"
-                        },
-                        {
-                            "highlight_end": 33,
-                            "highlight_start": 1,
-                            "text": "                  ($ ($ arg) +))"
-                        },
-                        {
-                            "highlight_end": 15,
-                            "highlight_start": 1,
-                            "text": "             }"
-                        },
-                        {
-                            "highlight_end": 11,
-                            "highlight_start": 1,
-                            "text": "         }"
-                        },
-                        {
-                            "highlight_end": 7,
-                            "highlight_start": 1,
-                            "text": "     }"
-                        },
-                        {
-                            "highlight_end": 6,
-                            "highlight_start": 1,
-                            "text": " }) ;"
-                        }
-                    ]
-                },
-                "macro_decl_name": "assert_eq!",
-                "span": {
-                    "byte_end": 38,
-                    "byte_start": 16,
-                    "column_end": 27,
-                    "column_start": 5,
-                    "expansion": null,
-                    "file_name": "src/main.rs",
-                    "is_primary": false,
-                    "label": null,
-                    "line_end": 2,
-                    "line_start": 2,
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "text": [
-                        {
-                            "highlight_end": 27,
-                            "highlight_start": 5,
-                            "text": "    assert_eq!(1, \"love\");"
-                        }
-                    ]
-                }
-            },
-            "file_name": "<::core::macros::assert_eq macros>",
-            "is_primary": true,
-            "label": "no implementation for `{integer} == &str`",
-            "line_end": 7,
-            "line_start": 7,
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "text": [
-                {
-                    "highlight_end": 33,
-                    "highlight_start": 31,
-                    "text": "             if ! (* left_val == * right_val)"
-                }
-            ]
-        }
-    ]
-}
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/error/E0308.json b/editors/code/src/test/fixtures/rust-diagnostics/error/E0308.json
deleted file mode 100644
index fb23824a3..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/error/E0308.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
-    "message": "mismatched types",
-    "code": {
-        "code": "E0308",
-        "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n//     ~~~   ~~~~~~~~~~~~~~~~~~~~\n//      |             |\n//      |    initializing expression;\n//      |    compiler infers type `&str`\n//      |\n//    type `i32` assigned to variable `x`\n```\n"
-    },
-    "level": "error",
-    "spans": [
-        {
-            "file_name": "runtime/compiler_support.rs",
-            "byte_start": 1589,
-            "byte_end": 1594,
-            "line_start": 48,
-            "line_end": 48,
-            "column_start": 65,
-            "column_end": 70,
-            "is_primary": true,
-            "text": [
-                {
-                    "text": "    let layout = alloc::Layout::from_size_align_unchecked(size, align);",
-                    "highlight_start": 65,
-                    "highlight_end": 70
-                }
-            ],
-            "label": "expected usize, found u32",
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        }
-    ],
-    "children": [],
-    "rendered": "error[E0308]: mismatched types\n  --> runtime/compiler_support.rs:48:65\n   |\n48 |     let layout = alloc::Layout::from_size_align_unchecked(size, align);\n   |                                                                 ^^^^^ expected usize, found u32\n\n"
-}
diff --git a/editors/code/src/test/fixtures/rust-diagnostics/warning/unused_variables.json b/editors/code/src/test/fixtures/rust-diagnostics/warning/unused_variables.json
deleted file mode 100644
index d1e2be722..000000000
--- a/editors/code/src/test/fixtures/rust-diagnostics/warning/unused_variables.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
-    "message": "unused variable: `foo`",
-    "code": {
-        "code": "unused_variables",
-        "explanation": null
-    },
-    "level": "warning",
-    "spans": [
-        {
-            "file_name": "driver/subcommand/repl.rs",
-            "byte_start": 9228,
-            "byte_end": 9231,
-            "line_start": 291,
-            "line_end": 291,
-            "column_start": 9,
-            "column_end": 12,
-            "is_primary": true,
-            "text": [
-                {
-                    "text": "    let foo = 42;",
-                    "highlight_start": 9,
-                    "highlight_end": 12
-                }
-            ],
-            "label": null,
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "expansion": null
-        }
-    ],
-    "children": [
-        {
-            "message": "#[warn(unused_variables)] on by default",
-            "code": null,
-            "level": "note",
-            "spans": [],
-            "children": [],
-            "rendered": null
-        },
-        {
-            "message": "consider prefixing with an underscore",
-            "code": null,
-            "level": "help",
-            "spans": [
-                {
-                    "file_name": "driver/subcommand/repl.rs",
-                    "byte_start": 9228,
-                    "byte_end": 9231,
-                    "line_start": 291,
-                    "line_end": 291,
-                    "column_start": 9,
-                    "column_end": 12,
-                    "is_primary": true,
-                    "text": [
-                        {
-                            "text": "    let foo = 42;",
-                            "highlight_start": 9,
-                            "highlight_end": 12
-                        }
-                    ],
-                    "label": null,
-                    "suggested_replacement": "_foo",
-                    "suggestion_applicability": "MachineApplicable",
-                    "expansion": null
-                }
-            ],
-            "children": [],
-            "rendered": null
-        }
-    ],
-    "rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
-}
diff --git a/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts b/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts
deleted file mode 100644
index 2b25eb705..000000000
--- a/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import * as assert from 'assert';
-import * as vscode from 'vscode';
-import { SuggestionApplicability } from '../../../utils/diagnostics/rust';
-import SuggestedFix from '../../../utils/diagnostics/SuggestedFix';
-const location1 = new vscode.Location(
-    vscode.Uri.file('/file/1'),
-    new vscode.Range(new vscode.Position(1, 2), new vscode.Position(3, 4)),
-);
-const location2 = new vscode.Location(
-    vscode.Uri.file('/file/2'),
-    new vscode.Range(new vscode.Position(5, 6), new vscode.Position(7, 8)),
-);
-describe('SuggestedFix', () => {
-    describe('isEqual', () => {
-        it('should treat identical instances as equal', () => {
-            const suggestion1 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            const suggestion2 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            assert(suggestion1.isEqual(suggestion2));
-        });
-        it('should treat instances with different titles as inequal', () => {
-            const suggestion1 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            const suggestion2 = new SuggestedFix(
-                'Not the same title!',
-                location1,
-                'With this!',
-            );
-            assert(!suggestion1.isEqual(suggestion2));
-        });
-        it('should treat instances with different replacements as inequal', () => {
-            const suggestion1 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            const suggestion2 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With something else!',
-            );
-            assert(!suggestion1.isEqual(suggestion2));
-        });
-        it('should treat instances with different locations as inequal', () => {
-            const suggestion1 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            const suggestion2 = new SuggestedFix(
-                'Replace me!',
-                location2,
-                'With this!',
-            );
-            assert(!suggestion1.isEqual(suggestion2));
-        });
-        it('should treat instances with different applicability as inequal', () => {
-            const suggestion1 = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-                SuggestionApplicability.MachineApplicable,
-            );
-            const suggestion2 = new SuggestedFix(
-                'Replace me!',
-                location2,
-                'With this!',
-                SuggestionApplicability.HasPlaceholders,
-            );
-            assert(!suggestion1.isEqual(suggestion2));
-        });
-    });
-    describe('toCodeAction', () => {
-        it('should map a simple suggestion', () => {
-            const suggestion = new SuggestedFix(
-                'Replace me!',
-                location1,
-                'With this!',
-            );
-            const codeAction = suggestion.toCodeAction();
-            assert.strictEqual(codeAction.kind, vscode.CodeActionKind.QuickFix);
-            assert.strictEqual(codeAction.title, 'Replace me!');
-            assert.strictEqual(codeAction.isPreferred, false);
-            const edit = codeAction.edit;
-            if (!edit) {
-                assert.fail('Code Action edit unexpectedly missing');
-                return;
-            }
-            const editEntries = edit.entries();
-            assert.strictEqual(editEntries.length, 1);
-            const [[editUri, textEdits]] = editEntries;
-            assert.strictEqual(editUri.toString(), location1.uri.toString());
-            assert.strictEqual(textEdits.length, 1);
-            const [textEdit] = textEdits;
-            assert(textEdit.range.isEqual(location1.range));
-            assert.strictEqual(textEdit.newText, 'With this!');
-        });
-    });
-});
diff --git a/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts b/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts
deleted file mode 100644
index ef09013f4..000000000
--- a/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-import * as assert from 'assert';
-import * as vscode from 'vscode';
-import SuggestedFix from '../../../utils/diagnostics/SuggestedFix';
-import SuggestedFixCollection from '../../../utils/diagnostics/SuggestedFixCollection';
-const uri1 = vscode.Uri.file('/file/1');
-const uri2 = vscode.Uri.file('/file/2');
-const mockDocument1 = ({
-    uri: uri1,
-} as unknown) as vscode.TextDocument;
-const mockDocument2 = ({
-    uri: uri2,
-} as unknown) as vscode.TextDocument;
-const range1 = new vscode.Range(
-    new vscode.Position(1, 2),
-    new vscode.Position(3, 4),
-);
-const range2 = new vscode.Range(
-    new vscode.Position(5, 6),
-    new vscode.Position(7, 8),
-);
-const diagnostic1 = new vscode.Diagnostic(range1, 'First diagnostic');
-const diagnostic2 = new vscode.Diagnostic(range2, 'Second diagnostic');
-// This is a mutable object so return a fresh instance every time
-function suggestion1(): SuggestedFix {
-    return new SuggestedFix(
-        'Replace me!',
-        new vscode.Location(uri1, range1),
-        'With this!',
-    );
-}
-describe('SuggestedFixCollection', () => {
-    it('should add a suggestion then return it as a code action', () => {
-        const suggestedFixes = new SuggestedFixCollection();
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1);
-        // Specify the document and range that exactly matches
-        const codeActions = suggestedFixes.provideCodeActions(
-            mockDocument1,
-            range1,
-        );
-        assert.strictEqual(codeActions.length, 1);
-        const [codeAction] = codeActions;
-        assert.strictEqual(codeAction.title, suggestion1().title);
-        const { diagnostics } = codeAction;
-        if (!diagnostics) {
-            assert.fail('Diagnostics unexpectedly missing');
-            return;
-        }
-        assert.strictEqual(diagnostics.length, 1);
-        assert.strictEqual(diagnostics[0], diagnostic1);
-    });
-    it('should not return code actions for different ranges', () => {
-        const suggestedFixes = new SuggestedFixCollection();
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1);
-        const codeActions = suggestedFixes.provideCodeActions(
-            mockDocument1,
-            range2,
-        );
-        assert(!codeActions || codeActions.length === 0);
-    });
-    it('should not return code actions for different documents', () => {
-        const suggestedFixes = new SuggestedFixCollection();
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1);
-        const codeActions = suggestedFixes.provideCodeActions(
-            mockDocument2,
-            range1,
-        );
-        assert(!codeActions || codeActions.length === 0);
-    });
-    it('should not return code actions that have been cleared', () => {
-        const suggestedFixes = new SuggestedFixCollection();
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1);
-        suggestedFixes.clear();
-        const codeActions = suggestedFixes.provideCodeActions(
-            mockDocument1,
-            range1,
-        );
-        assert(!codeActions || codeActions.length === 0);
-    });
-    it('should merge identical suggestions together', () => {
-        const suggestedFixes = new SuggestedFixCollection();
-        // Add the same suggestion for two diagnostics
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1);
-        suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic2);
-        const codeActions = suggestedFixes.provideCodeActions(
-            mockDocument1,
-            range1,
-        );
-        assert.strictEqual(codeActions.length, 1);
-        const [codeAction] = codeActions;
-        const { diagnostics } = codeAction;
-        if (!diagnostics) {
-            assert.fail('Diagnostics unexpectedly missing');
-            return;
-        }
-        // We should be associated with both diagnostics
-        assert.strictEqual(diagnostics.length, 2);
-        assert.strictEqual(diagnostics[0], diagnostic1);
-        assert.strictEqual(diagnostics[1], diagnostic2);
-    });
-});
diff --git a/editors/code/src/test/utils/diagnotics/rust.test.ts b/editors/code/src/test/utils/diagnotics/rust.test.ts
deleted file mode 100644
index 358325cc8..000000000
--- a/editors/code/src/test/utils/diagnotics/rust.test.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-import * as assert from 'assert';
-import * as fs from 'fs';
-import * as vscode from 'vscode';
-import {
-    MappedRustDiagnostic,
-    mapRustDiagnosticToVsCode,
-    RustDiagnostic,
-    SuggestionApplicability,
-} from '../../../utils/diagnostics/rust';
-function loadDiagnosticFixture(name: string): RustDiagnostic {
-    const jsonText = fs
-        .readFileSync(
-            // We're actually in our JavaScript output directory, climb out
-            `${__dirname}/../../../../src/test/fixtures/rust-diagnostics/${name}.json`,
-        )
-        .toString();
-    return JSON.parse(jsonText);
-}
-function mapFixtureToVsCode(name: string): MappedRustDiagnostic {
-    const rd = loadDiagnosticFixture(name);
-    const mapResult = mapRustDiagnosticToVsCode(rd);
-    if (!mapResult) {
-        return assert.fail('Mapping unexpectedly failed');
-    }
-    return mapResult;
-}
-describe('mapRustDiagnosticToVsCode', () => {
-    it('should map an incompatible type for trait error', () => {
-        const { diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'error/E0053',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert.strictEqual(diagnostic.source, 'rustc');
-        assert.strictEqual(
-            diagnostic.message,
-            [
-                `method \`next\` has an incompatible type for trait`,
-                `expected type \`fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>\``,
-                `   found type \`fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>\``,
-            ].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'E0053');
-        assert.deepStrictEqual(diagnostic.tags, []);
-        // No related information
-        assert.deepStrictEqual(diagnostic.relatedInformation, []);
-        // There are no suggested fixes
-        assert.strictEqual(suggestedFixes.length, 0);
-    });
-    it('should map an unused variable warning', () => {
-        const { diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'warning/unused_variables',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Warning,
-        );
-        assert.strictEqual(
-            diagnostic.message,
-            [
-                'unused variable: `foo`',
-                '#[warn(unused_variables)] on by default',
-            ].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'unused_variables');
-        assert.strictEqual(diagnostic.source, 'rustc');
-        assert.deepStrictEqual(diagnostic.tags, [
-            vscode.DiagnosticTag.Unnecessary,
-        ]);
-        // No related information
-        assert.deepStrictEqual(diagnostic.relatedInformation, []);
-        // One suggested fix available to prefix the variable
-        assert.strictEqual(suggestedFixes.length, 1);
-        const [suggestedFix] = suggestedFixes;
-        assert.strictEqual(
-            suggestedFix.title,
-            'consider prefixing with an underscore: `_foo`',
-        );
-        assert.strictEqual(
-            suggestedFix.applicability,
-            SuggestionApplicability.MachineApplicable,
-        );
-    });
-    it('should map a wrong number of parameters error', () => {
-        const { diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'error/E0061',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert.strictEqual(
-            diagnostic.message,
-            [
-                'this function takes 2 parameters but 3 parameters were supplied',
-                'expected 2 parameters',
-            ].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'E0061');
-        assert.strictEqual(diagnostic.source, 'rustc');
-        assert.deepStrictEqual(diagnostic.tags, []);
-        // One related information for the original definition
-        const relatedInformation = diagnostic.relatedInformation;
-        if (!relatedInformation) {
-            assert.fail('Related information unexpectedly undefined');
-            return;
-        }
-        assert.strictEqual(relatedInformation.length, 1);
-        const [related] = relatedInformation;
-        assert.strictEqual(related.message, 'defined here');
-        // There are no suggested fixes
-        assert.strictEqual(suggestedFixes.length, 0);
-    });
-    it('should map a Clippy copy pass by ref warning', () => {
-        const { diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'clippy/trivially_copy_pass_by_ref',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Warning,
-        );
-        assert.strictEqual(diagnostic.source, 'clippy');
-        assert.strictEqual(
-            diagnostic.message,
-            [
-                'this argument is passed by reference, but would be more efficient if passed by value',
-                '#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]',
-                'for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref',
-            ].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'trivially_copy_pass_by_ref');
-        assert.deepStrictEqual(diagnostic.tags, []);
-        // One related information for the lint definition
-        const relatedInformation = diagnostic.relatedInformation;
-        if (!relatedInformation) {
-            assert.fail('Related information unexpectedly undefined');
-            return;
-        }
-        assert.strictEqual(relatedInformation.length, 1);
-        const [related] = relatedInformation;
-        assert.strictEqual(related.message, 'lint level defined here');
-        // One suggested fix to pass by value
-        assert.strictEqual(suggestedFixes.length, 1);
-        const [suggestedFix] = suggestedFixes;
-        assert.strictEqual(
-            suggestedFix.title,
-            'consider passing by value instead: `self`',
-        );
-        // Clippy does not mark this with any applicability
-        assert.strictEqual(
-            suggestedFix.applicability,
-            SuggestionApplicability.Unspecified,
-        );
-    });
-    it('should map a mismatched type error', () => {
-        const { diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'error/E0308',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert.strictEqual(
-            diagnostic.message,
-            ['mismatched types', 'expected usize, found u32'].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'E0308');
-        assert.strictEqual(diagnostic.source, 'rustc');
-        assert.deepStrictEqual(diagnostic.tags, []);
-        // No related information
-        assert.deepStrictEqual(diagnostic.relatedInformation, []);
-        // There are no suggested fixes
-        assert.strictEqual(suggestedFixes.length, 0);
-    });
-    it('should map a macro invocation location to normal file path', () => {
-        const { location, diagnostic, suggestedFixes } = mapFixtureToVsCode(
-            'error/E0277',
-        );
-        assert.strictEqual(
-            diagnostic.severity,
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert.strictEqual(
-            diagnostic.message,
-            [
-                "can't compare `{integer}` with `&str`",
-                'the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`',
-            ].join('\n'),
-        );
-        assert.strictEqual(diagnostic.code, 'E0277');
-        assert.strictEqual(diagnostic.source, 'rustc');
-        assert.deepStrictEqual(diagnostic.tags, []);
-        // No related information
-        assert.deepStrictEqual(diagnostic.relatedInformation, []);
-        // There are no suggested fixes
-        assert.strictEqual(suggestedFixes.length, 0);
-        // The file url should be normal file
-        // Ignore the first part because it depends on vs workspace location
-        assert.strictEqual(
-            location.uri.path.substr(-'src/main.rs'.length),
-            'src/main.rs',
-        );
-    });
-});
diff --git a/editors/code/src/test/utils/diagnotics/vscode.test.ts b/editors/code/src/test/utils/diagnotics/vscode.test.ts
deleted file mode 100644
index 4944dd032..000000000
--- a/editors/code/src/test/utils/diagnotics/vscode.test.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import * as assert from 'assert';
-import * as vscode from 'vscode';
-import { areDiagnosticsEqual } from '../../../utils/diagnostics/vscode';
-const range1 = new vscode.Range(
-    new vscode.Position(1, 2),
-    new vscode.Position(3, 4),
-);
-const range2 = new vscode.Range(
-    new vscode.Position(5, 6),
-    new vscode.Position(7, 8),
-);
-describe('areDiagnosticsEqual', () => {
-    it('should treat identical diagnostics as equal', () => {
-        const diagnostic1 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        const diagnostic2 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert(areDiagnosticsEqual(diagnostic1, diagnostic2));
-    });
-    it('should treat diagnostics with different sources as inequal', () => {
-        const diagnostic1 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        diagnostic1.source = 'rustc';
-        const diagnostic2 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        diagnostic2.source = 'clippy';
-        assert(!areDiagnosticsEqual(diagnostic1, diagnostic2));
-    });
-    it('should treat diagnostics with different ranges as inequal', () => {
-        const diagnostic1 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        const diagnostic2 = new vscode.Diagnostic(
-            range2,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert(!areDiagnosticsEqual(diagnostic1, diagnostic2));
-    });
-    it('should treat diagnostics with different messages as inequal', () => {
-        const diagnostic1 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        const diagnostic2 = new vscode.Diagnostic(
-            range1,
-            'Goodbye!, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert(!areDiagnosticsEqual(diagnostic1, diagnostic2));
-    });
-    it('should treat diagnostics with different severities as inequal', () => {
-        const diagnostic1 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Warning,
-        );
-        const diagnostic2 = new vscode.Diagnostic(
-            range1,
-            'Hello, world!',
-            vscode.DiagnosticSeverity.Error,
-        );
-        assert(!areDiagnosticsEqual(diagnostic1, diagnostic2));
-    });
-});
diff --git a/editors/code/src/utils/diagnostics/SuggestedFix.ts b/editors/code/src/utils/diagnostics/SuggestedFix.ts
deleted file mode 100644
index 6e660bb61..000000000
--- a/editors/code/src/utils/diagnostics/SuggestedFix.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import * as vscode from 'vscode';
-import { SuggestionApplicability } from './rust';
-/**
- * Model object for text replacements suggested by the Rust compiler
- *
- * This is an intermediate form between the raw `rustc` JSON and a
- * `vscode.CodeAction`. It's optimised for the use-cases of
- * `SuggestedFixCollection`.
- */
-export default class SuggestedFix {
-    public readonly title: string;
-    public readonly location: vscode.Location;
-    public readonly replacement: string;
-    public readonly applicability: SuggestionApplicability;
-    /**
-     * Diagnostics this suggested fix could resolve
-     */
-    public diagnostics: vscode.Diagnostic[];
-    constructor(
-        title: string,
-        location: vscode.Location,
-        replacement: string,
-        applicability: SuggestionApplicability = SuggestionApplicability.Unspecified,
-    ) {
-        this.title = title;
-        this.location = location;
-        this.replacement = replacement;
-        this.applicability = applicability;
-        this.diagnostics = [];
-    }
-    /**
-     * Determines if this suggested fix is equivalent to another instance
-     */
-    public isEqual(other: SuggestedFix): boolean {
-        return (
-            this.title === other.title &&
-            this.location.range.isEqual(other.location.range) &&
-            this.replacement === other.replacement &&
-            this.applicability === other.applicability
-        );
-    }
-    /**
-     * Converts this suggested fix to a VS Code Quick Fix code action
-     */
-    public toCodeAction(): vscode.CodeAction {
-        const codeAction = new vscode.CodeAction(
-            this.title,
-            vscode.CodeActionKind.QuickFix,
-        );
-        const edit = new vscode.WorkspaceEdit();
-        edit.replace(this.location.uri, this.location.range, this.replacement);
-        codeAction.edit = edit;
-        codeAction.isPreferred =
-            this.applicability === SuggestionApplicability.MachineApplicable;
-        codeAction.diagnostics = [...this.diagnostics];
-        return codeAction;
-    }
-}
diff --git a/editors/code/src/utils/diagnostics/SuggestedFixCollection.ts b/editors/code/src/utils/diagnostics/SuggestedFixCollection.ts
deleted file mode 100644
index 57c9856cf..000000000
--- a/editors/code/src/utils/diagnostics/SuggestedFixCollection.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import * as vscode from 'vscode';
-import SuggestedFix from './SuggestedFix';
-/**
- * Collection of suggested fixes across multiple documents
- *
- * This stores `SuggestedFix` model objects and returns them via the
- * `vscode.CodeActionProvider` interface.
- */
-export default class SuggestedFixCollection
-    implements vscode.CodeActionProvider {
-    public static PROVIDED_CODE_ACTION_KINDS = [vscode.CodeActionKind.QuickFix];
-    /**
-     * Map of document URI strings to suggested fixes
-     */
-    private suggestedFixes: Map<string, SuggestedFix[]>;
-    constructor() {
-        this.suggestedFixes = new Map();
-    }
-    /**
-     * Clears all suggested fixes across all documents
-     */
-    public clear(): void {
-        this.suggestedFixes = new Map();
-    }
-    /**
-     * Adds a suggested fix for the given diagnostic
-     *
-     * Some suggested fixes will appear in multiple diagnostics. For example,
-     * forgetting a `mut` on a variable will suggest changing the delaration on
-     * every mutable usage site. If the suggested fix has already been added
-     * this method will instead associate the existing fix with the new
-     * diagnostic.
-     */
-    public addSuggestedFixForDiagnostic(
-        suggestedFix: SuggestedFix,
-        diagnostic: vscode.Diagnostic,
-    ): void {
-        const fileUriString = suggestedFix.location.uri.toString();
-        const fileSuggestions = this.suggestedFixes.get(fileUriString) || [];
-        const existingSuggestion = fileSuggestions.find(s =>
-            s.isEqual(suggestedFix),
-        );
-        if (existingSuggestion) {
-            // The existing suggestion also applies to this new diagnostic
-            existingSuggestion.diagnostics.push(diagnostic);
-        } else {
-            // We haven't seen this suggestion before
-            suggestedFix.diagnostics.push(diagnostic);
-            fileSuggestions.push(suggestedFix);
-        }
-        this.suggestedFixes.set(fileUriString, fileSuggestions);
-    }
-    /**
-     * Filters suggested fixes by their document and range and converts them to
-     * code actions
-     */
-    public provideCodeActions(
-        document: vscode.TextDocument,
-        range: vscode.Range,
-    ): vscode.CodeAction[] {
-        const documentUriString = document.uri.toString();
-        const suggestedFixes = this.suggestedFixes.get(documentUriString);
-        return (suggestedFixes || [])
-            .filter(({ location }) => location.range.intersection(range))
-            .map(suggestedEdit => suggestedEdit.toCodeAction());
-    }
-}
diff --git a/editors/code/src/utils/diagnostics/rust.ts b/editors/code/src/utils/diagnostics/rust.ts
deleted file mode 100644
index 1f0c0d3e4..000000000
--- a/editors/code/src/utils/diagnostics/rust.ts
+++ /dev/null
@@ -1,299 +0,0 @@
-import * as path from 'path';
-import * as vscode from 'vscode';
-import SuggestedFix from './SuggestedFix';
-export enum SuggestionApplicability {
-    MachineApplicable = 'MachineApplicable',
-    HasPlaceholders = 'HasPlaceholders',
-    MaybeIncorrect = 'MaybeIncorrect',
-    Unspecified = 'Unspecified',
-}
-export interface RustDiagnosticSpanMacroExpansion {
-    span: RustDiagnosticSpan;
-    macro_decl_name: string;
-    def_site_span?: RustDiagnosticSpan;
-}
-// Reference:
-// https://github.com/rust-lang/rust/blob/master/src/libsyntax/json.rs
-export interface RustDiagnosticSpan {
-    line_start: number;
-    line_end: number;
-    column_start: number;
-    column_end: number;
-    is_primary: boolean;
-    file_name: string;
-    label?: string;
-    expansion?: RustDiagnosticSpanMacroExpansion;
-    suggested_replacement?: string;
-    suggestion_applicability?: SuggestionApplicability;
-}
-export interface RustDiagnostic {
-    spans: RustDiagnosticSpan[];
-    rendered: string;
-    message: string;
-    level: string;
-    code?: {
-        code: string;
-    };
-    children: RustDiagnostic[];
-}
-export interface MappedRustDiagnostic {
-    location: vscode.Location;
-    diagnostic: vscode.Diagnostic;
-    suggestedFixes: SuggestedFix[];
-}
-interface MappedRustChildDiagnostic {
-    related?: vscode.DiagnosticRelatedInformation;
-    suggestedFix?: SuggestedFix;
-    messageLine?: string;
-}
-/**
- * Converts a Rust level string to a VsCode severity
- */
-function mapLevelToSeverity(s: string): vscode.DiagnosticSeverity {
-    if (s === 'error') {
-        return vscode.DiagnosticSeverity.Error;
-    }
-    if (s.startsWith('warn')) {
-        return vscode.DiagnosticSeverity.Warning;
-    }
-    return vscode.DiagnosticSeverity.Information;
-}
-/**
- * Check whether a file name is from macro invocation
- */
-function isFromMacro(fileName: string): boolean {
-    return fileName.startsWith('<') && fileName.endsWith('>');
-}
-/**
- * Converts a Rust macro span to a VsCode location recursively
- */
-function mapMacroSpanToLocation(
-    spanMacro: RustDiagnosticSpanMacroExpansion,
-): vscode.Location | undefined {
-    if (!isFromMacro(spanMacro.span.file_name)) {
-        return mapSpanToLocation(spanMacro.span);
-    }
-    if (spanMacro.span.expansion) {
-        return mapMacroSpanToLocation(spanMacro.span.expansion);
-    }
-    return;
-}
-/**
- * Converts a Rust span to a VsCode location
- */
-function mapSpanToLocation(span: RustDiagnosticSpan): vscode.Location {
-    if (isFromMacro(span.file_name) && span.expansion) {
-        const macroLoc = mapMacroSpanToLocation(span.expansion);
-        if (macroLoc) {
-            return macroLoc;
-        }
-    }
-    const fileName = path.join(vscode.workspace.rootPath || '', span.file_name);
-    const fileUri = vscode.Uri.file(fileName);
-    const range = new vscode.Range(
-        new vscode.Position(span.line_start - 1, span.column_start - 1),
-        new vscode.Position(span.line_end - 1, span.column_end - 1),
-    );
-    return new vscode.Location(fileUri, range);
-}
-/**
- * Converts a secondary Rust span to a VsCode related information
- *
- * If the span is unlabelled this will return `undefined`.
- */
-function mapSecondarySpanToRelated(
-    span: RustDiagnosticSpan,
-): vscode.DiagnosticRelatedInformation | undefined {
-    if (!span.label) {
-        // Nothing to label this with
-        return;
-    }
-    const location = mapSpanToLocation(span);
-    return new vscode.DiagnosticRelatedInformation(location, span.label);
-}
-/**
- * Determines if diagnostic is related to unused code
- */
-function isUnusedOrUnnecessary(rd: RustDiagnostic): boolean {
-    if (!rd.code) {
-        return false;
-    }
-    return [
-        'dead_code',
-        'unknown_lints',
-        'unreachable_code',
-        'unused_attributes',
-        'unused_imports',
-        'unused_macros',
-        'unused_variables',
-    ].includes(rd.code.code);
-}
-/**
- * Determines if diagnostic is related to deprecated code
- */
-function isDeprecated(rd: RustDiagnostic): boolean {
-    if (!rd.code) {
-        return false;
-    }
-    return ['deprecated'].includes(rd.code.code);
-}
-/**
- * Converts a Rust child diagnostic to a VsCode related information
- *
- * This can have three outcomes:
- *
- * 1. If this is no primary span this will return a `noteLine`
- * 2. If there is a primary span with a suggested replacement it will return a
- *    `codeAction`.
- * 3. If there is a primary span without a suggested replacement it will return
- *    a `related`.
- */
-function mapRustChildDiagnostic(rd: RustDiagnostic): MappedRustChildDiagnostic {
-    const span = rd.spans.find(s => s.is_primary);
-    if (!span) {
-        // `rustc` uses these spanless children as a way to print multi-line
-        // messages
-        return { messageLine: rd.message };
-    }
-    // If we have a primary span use its location, otherwise use the parent
-    const location = mapSpanToLocation(span);
-    // We need to distinguish `null` from an empty string
-    if (span && typeof span.suggested_replacement === 'string') {
-        // Include our replacement in the title unless it's empty
-        const title = span.suggested_replacement
-            ? `${rd.message}: \`${span.suggested_replacement}\``
-            : rd.message;
-        return {
-            suggestedFix: new SuggestedFix(
-                title,
-                location,
-                span.suggested_replacement,
-                span.suggestion_applicability,
-            ),
-        };
-    } else {
-        const related = new vscode.DiagnosticRelatedInformation(
-            location,
-            rd.message,
-        );
-        return { related };
-    }
-}
-/**
- * Converts a Rust root diagnostic to VsCode form
- *
- * This flattens the Rust diagnostic by:
- *
- * 1. Creating a `vscode.Diagnostic` with the root message and primary span.
- * 2. Adding any labelled secondary spans to `relatedInformation`
- * 3. Categorising child diagnostics as either `SuggestedFix`es,
- *    `relatedInformation` or additional message lines.
- *
- * If the diagnostic has no primary span this will return `undefined`
- */
-export function mapRustDiagnosticToVsCode(
-    rd: RustDiagnostic,
-): MappedRustDiagnostic | undefined {
-    const primarySpan = rd.spans.find(s => s.is_primary);
-    if (!primarySpan) {
-        return;
-    }
-    const location = mapSpanToLocation(primarySpan);
-    const secondarySpans = rd.spans.filter(s => !s.is_primary);
-    const severity = mapLevelToSeverity(rd.level);
-    let primarySpanLabel = primarySpan.label;
-    const vd = new vscode.Diagnostic(location.range, rd.message, severity);
-    let source = 'rustc';
-    let code = rd.code && rd.code.code;
-    if (code) {
-        // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
-        const scopedCode = code.split('::');
-        if (scopedCode.length === 2) {
-            [source, code] = scopedCode;
-        }
-    }
-    vd.source = source;
-    vd.code = code;
-    vd.relatedInformation = [];
-    vd.tags = [];
-    for (const secondarySpan of secondarySpans) {
-        const related = mapSecondarySpanToRelated(secondarySpan);
-        if (related) {
-            vd.relatedInformation.push(related);
-        }
-    }
-    const suggestedFixes = [];
-    for (const child of rd.children) {
-        const { related, suggestedFix, messageLine } = mapRustChildDiagnostic(
-            child,
-        );
-        if (related) {
-            vd.relatedInformation.push(related);
-        }
-        if (suggestedFix) {
-            suggestedFixes.push(suggestedFix);
-        }
-        if (messageLine) {
-            vd.message += `\n${messageLine}`;
-            // These secondary messages usually duplicate the content of the
-            // primary span label.
-            primarySpanLabel = undefined;
-        }
-    }
-    if (primarySpanLabel) {
-        vd.message += `\n${primarySpanLabel}`;
-    }
-    if (isUnusedOrUnnecessary(rd)) {
-        vd.tags.push(vscode.DiagnosticTag.Unnecessary);
-    }
-    if (isDeprecated(rd)) {
-        vd.tags.push(vscode.DiagnosticTag.Deprecated);
-    }
-    return {
-        location,
-        diagnostic: vd,
-        suggestedFixes,
-    };
-}
diff --git a/editors/code/src/utils/diagnostics/vscode.ts b/editors/code/src/utils/diagnostics/vscode.ts
deleted file mode 100644
index f4a5450e2..000000000
--- a/editors/code/src/utils/diagnostics/vscode.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import * as vscode from 'vscode';
-/** Compares two `vscode.Diagnostic`s for equality */
-export function areDiagnosticsEqual(
-    left: vscode.Diagnostic,
-    right: vscode.Diagnostic,
-): boolean {
-    return (
-        left.source === right.source &&
-        left.severity === right.severity &&
-        left.range.isEqual(right.range) &&
-        left.message === right.message
-    );
-}
diff --git a/editors/code/src/utils/processes.ts b/editors/code/src/utils/processes.ts
deleted file mode 100644
index a1d6b7eaf..000000000
--- a/editors/code/src/utils/processes.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-'use strict';
-import * as cp from 'child_process';
-import ChildProcess = cp.ChildProcess;
-import { join } from 'path';
-const isWindows = process.platform === 'win32';
-const isMacintosh = process.platform === 'darwin';
-const isLinux = process.platform === 'linux';
-// this is very complex, but is basically copy-pased from VSCode implementation here:
-// https://github.com/Microsoft/vscode-languageserver-node/blob/dbfd37e35953ad0ee14c4eeced8cfbc41697b47e/client/src/utils/processes.ts#L15
-// And see discussion at
-// https://github.com/rust-analyzer/rust-analyzer/pull/1079#issuecomment-478908109
-export function terminate(process: ChildProcess, cwd?: string): boolean {
-    if (isWindows) {
-        try {
-            // This we run in Atom execFileSync is available.
-            // Ignore stderr since this is otherwise piped to parent.stderr
-            // which might be already closed.
-            const options: any = {
-                stdio: ['pipe', 'pipe', 'ignore'],
-            };
-            if (cwd) {
-                options.cwd = cwd;
-            }
-            cp.execFileSync(
-                'taskkill',
-                ['/T', '/F', '/PID', process.pid.toString()],
-                options,
-            );
-            return true;
-        } catch (err) {
-            return false;
-        }
-    } else if (isLinux || isMacintosh) {
-        try {
-            const cmd = join(__dirname, 'terminateProcess.sh');
-            const result = cp.spawnSync(cmd, [process.pid.toString()]);
-            return result.error ? false : true;
-        } catch (err) {
-            return false;
-        }
-    } else {
-        process.kill('SIGKILL');
-        return true;
-    }
-}
diff --git a/editors/code/src/utils/terminateProcess.sh b/editors/code/src/utils/terminateProcess.sh
deleted file mode 100644
index 2ec9e1c2e..000000000
--- a/editors/code/src/utils/terminateProcess.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-terminateTree() {
-    for cpid in $(pgrep -P $1); do
-        terminateTree $cpid
-    done
-    kill -9 $1 > /dev/null 2>&1
-}
-for pid in $*; do
-    terminateTree $pid
-done
-\ No newline at end of file
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 4201c6a6a..9cefad925 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -226,7 +226,7 @@ fn install_client(ClientOpt::VsCode: ClientOpt) -> Result<()> {
    if !str::from_utf8(&output.stdout)?.contains("ra-lsp") {
        anyhow::bail!(
            "Could not install the Visual Studio Code extension. \
-             Please make sure you have at least NodeJS 10.x installed and try again."
+             Please make sure you have at least NodeJS 10.x together with the latest version of VS Code installed and try again."
        );
    }
diff --git a/xtask/tests/tidy-tests/cli.rs b/xtask/tests/tidy-tests/cli.rs
index 573ffadbf..f9ca45292 100644
--- a/xtask/tests/tidy-tests/cli.rs
+++ b/xtask/tests/tidy-tests/cli.rs
@@ -43,7 +43,7 @@ fn no_todo() {
            return;
        }
        let text = std::fs::read_to_string(e.path()).unwrap();
-        if text.contains("TODO") || text.contains("TOOD") {
+        if text.contains("TODO") || text.contains("TOOD") || text.contains("todo!") {
            panic!(
                "\nTODO markers should not be committed to the master branch,\n\
                 use FIXME instead\n\