32 files changed, 906 insertions, 840 deletions
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
new file mode 100644
index 000000000..864373aa5
--- /dev/null
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -0,0 +1,206 @@
+use ra_syntax::{
+    ast::{self, AstNode, NameOwner},
+    TextUnit,
+};
+use stdx::format_to;
+use crate::{Assist, AssistCtx, AssistId};
+use ra_ide_db::RootDatabase;
+// Assist add_from_impl_for_enum
+//
+// Adds a From impl for an enum variant with one tuple field
+//
+// ```
+// enum A { <|>One(u32) }
+// ```
+// ->
+// ```
+// enum A { One(u32) }
+//
+// impl From<u32> for A {
+//     fn from(v: u32) -> Self {
+//         A::One(v)
+//     }
+// }
+// ```
+pub(crate) fn add_from_impl_for_enum(ctx: AssistCtx) -> Option<Assist> {
+    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant_name = variant.name()?;
+    let enum_name = variant.parent_enum().name()?;
+    let field_list = match variant.kind() {
+        ast::StructKind::Tuple(field_list) => field_list,
+        _ => return None,
+    };
+    if field_list.fields().count() != 1 {
+        return None;
+    }
+    let field_type = field_list.fields().next()?.type_ref()?;
+    let path = match field_type {
+        ast::TypeRef::PathType(p) => p,
+        _ => return None,
+    };
+    if already_has_from_impl(ctx.sema, &variant) {
+        return None;
+    }
+    ctx.add_assist(
+        AssistId("add_from_impl_for_enum"),
+        "Add From impl for this enum variant",
+        |edit| {
+            let start_offset = variant.parent_enum().syntax().text_range().end();
+            let mut buf = String::new();
+            format_to!(
+                buf,
+                r#"
+impl From<{0}> for {1} {{
+    fn from(v: {0}) -> Self {{
+        {1}::{2}(v)
+    }}
+}}"#,
+                path.syntax(),
+                enum_name,
+                variant_name
+            );
+            edit.insert(start_offset, buf);
+            edit.set_cursor(start_offset + TextUnit::of_str("\n\n"));
+        },
+    )
+}
+fn already_has_from_impl(
+    sema: &'_ hir::Semantics<'_, RootDatabase>,
+    variant: &ast::EnumVariant,
+) -> bool {
+    let scope = sema.scope(&variant.syntax());
+    let from_path = ast::make::path_from_text("From");
+    let from_hir_path = match hir::Path::from_ast(from_path) {
+        Some(p) => p,
+        None => return false,
+    };
+    let from_trait = match scope.resolve_hir_path(&from_hir_path) {
+        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(t))) => t,
+        _ => return false,
+    };
+    let e: hir::Enum = match sema.to_def(&variant.parent_enum()) {
+        Some(e) => e,
+        None => return false,
+    };
+    let e_ty = e.ty(sema.db);
+    let hir_enum_var: hir::EnumVariant = match sema.to_def(variant) {
+        Some(ev) => ev,
+        None => return false,
+    };
+    let var_ty = hir_enum_var.fields(sema.db)[0].signature_ty(sema.db);
+    e_ty.impls_trait(sema.db, from_trait, &[var_ty.clone()])
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+    #[test]
+    fn test_add_from_impl_for_enum() {
+        check_assist(
+            add_from_impl_for_enum,
+            "enum A { <|>One(u32) }",
+            r#"enum A { One(u32) }
+<|>impl From<u32> for A {
+    fn from(v: u32) -> Self {
+        A::One(v)
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_add_from_impl_for_enum_complicated_path() {
+        check_assist(
+            add_from_impl_for_enum,
+            "enum A { <|>One(foo::bar::baz::Boo) }",
+            r#"enum A { One(foo::bar::baz::Boo) }
+<|>impl From<foo::bar::baz::Boo> for A {
+    fn from(v: foo::bar::baz::Boo) -> Self {
+        A::One(v)
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_add_from_impl_no_element() {
+        check_assist_not_applicable(add_from_impl_for_enum, "enum A { <|>One }");
+    }
+    #[test]
+    fn test_add_from_impl_more_than_one_element_in_tuple() {
+        check_assist_not_applicable(add_from_impl_for_enum, "enum A { <|>One(u32, String) }");
+    }
+    #[test]
+    fn test_add_from_impl_struct_variant() {
+        check_assist_not_applicable(add_from_impl_for_enum, "enum A { <|>One { x: u32 } }");
+    }
+    #[test]
+    fn test_add_from_impl_already_exists() {
+        check_assist_not_applicable(
+            add_from_impl_for_enum,
+            r#"enum A { <|>One(u32), }
+impl From<u32> for A {
+    fn from(v: u32) -> Self {
+        A::One(v)
+    }
+}
+pub trait From<T> {
+    fn from(T) -> Self;
+}"#,
+        );
+    }
+    #[test]
+    fn test_add_from_impl_different_variant_impl_exists() {
+        check_assist(
+            add_from_impl_for_enum,
+            r#"enum A { <|>One(u32), Two(String), }
+impl From<String> for A {
+    fn from(v: String) -> Self {
+        A::Two(v)
+    }
+}
+pub trait From<T> {
+    fn from(T) -> Self;
+}"#,
+            r#"enum A { One(u32), Two(String), }
+<|>impl From<u32> for A {
+    fn from(v: u32) -> Self {
+        A::One(v)
+    }
+}
+impl From<String> for A {
+    fn from(v: String) -> Self {
+        A::Two(v)
+    }
+}
+pub trait From<T> {
+    fn from(T) -> Self;
+}"#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 66854cb5a..fa3d3913f 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -123,6 +123,7 @@ mod handlers {
    mod replace_qualified_name_with_use;
    mod replace_unwrap_with_match;
    mod split_import;
+    mod add_from_impl_for_enum;
    pub(crate) fn all() -> &'static [AssistHandler] {
        &[
@@ -161,6 +162,7 @@ mod handlers {
            replace_qualified_name_with_use::replace_qualified_name_with_use,
            replace_unwrap_with_match::replace_unwrap_with_match,
            split_import::split_import,
+            add_from_impl_for_enum::add_from_impl_for_enum,
        ]
    }
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index cd2a8fc62..c6f3bdb8e 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1084,6 +1084,26 @@ impl Type {
        )
    }
+    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
+        let trait_ref = hir_ty::TraitRef {
+            trait_: trait_.id,
+            substs: Substs::build_for_def(db, trait_.id)
+                .push(self.ty.value.clone())
+                .fill(args.iter().map(|t| t.ty.value.clone()))
+                .build(),
+        };
+        let goal = Canonical {
+            value: hir_ty::InEnvironment::new(
+                self.ty.environment.clone(),
+                hir_ty::Obligation::Trait(trait_ref),
+            ),
+            num_vars: 0,
+        };
+        db.trait_solve(self.krate, goal).is_some()
+    }
    // FIXME: this method is broken, as it doesn't take closures into account.
    pub fn as_callable(&self) -> Option<CallableDef> {
        Some(self.ty.value.as_callable()?.0)
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index baed6225b..86acd27f8 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -11,7 +11,7 @@ use hir_def::{
 use hir_expand::name::Name;
 use test_utils::tested_by;
-use super::{BindingMode, InferenceContext};
+use super::{BindingMode, Expectation, InferenceContext};
 use crate::{utils::variant_data, Substs, Ty, TypeCtor};
 impl<'a> InferenceContext<'a> {
@@ -198,7 +198,14 @@ impl<'a> InferenceContext<'a> {
                Ty::apply_one(container_ty, elem_ty)
            }
-            _ => Ty::Unknown,
+            Pat::Wild => expected.clone(),
+            Pat::Range { start, end } => {
+                let start_ty = self.infer_expr(*start, &Expectation::has_type(expected.clone()));
+                let end_ty = self.infer_expr(*end, &Expectation::has_type(start_ty));
+                end_ty
+            }
+            Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())),
+            Pat::Missing => Ty::Unknown,
        };
        // use a new type variable if we got Ty::Unknown here
        let ty = self.insert_type_vars_shallow(ty);
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 1e303f5ce..3e3d55c04 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -275,12 +275,14 @@ fn test(i: i32) {
    [70; 147) 'match ...     }': &[i32]
    [76; 77) 'i': i32
    [88; 89) '2': i32
+    [88; 89) '2': i32
    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [93; 102) 'foo(&[2])': &[i32]
    [97; 101) '&[2]': &[i32; _]
    [98; 101) '[2]': [i32; _]
    [99; 100) '2': i32
    [112; 113) '1': i32
+    [112; 113) '1': i32
    [117; 121) '&[1]': &[i32; _]
    [118; 121) '[1]': [i32; _]
    [119; 120) '1': i32
@@ -316,10 +318,12 @@ fn test(i: i32) {
    [70; 147) 'match ...     }': &[i32]
    [76; 77) 'i': i32
    [88; 89) '1': i32
+    [88; 89) '1': i32
    [93; 97) '&[1]': &[i32; _]
    [94; 97) '[1]': [i32; _]
    [95; 96) '1': i32
    [107; 108) '2': i32
+    [107; 108) '2': i32
    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [112; 121) 'foo(&[2])': &[i32]
    [116; 120) '&[2]': &[i32; _]
@@ -357,9 +361,11 @@ fn test() {
    [45; 142) 'match ...     }': *const i32
    [51; 52) '1': i32
    [63; 64) '1': i32
+    [63; 64) '1': i32
    [68; 69) 't': &mut i32
    [68; 81) 't as *mut i32': *mut i32
    [91; 92) '2': i32
+    [91; 92) '2': i32
    [96; 97) 't': &mut i32
    [96; 105) 't as &i32': &i32
    [115; 116) '_': i32
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 76aa32024..6e5d2247c 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -82,6 +82,90 @@ fn test(x: &i32) {
 }
 #[test]
+fn infer_literal_pattern() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn any<T>() -> T { loop {} }
+fn test(x: &i32) {
+    if let "foo" = any() {}
+    if let 1 = any() {}
+    if let 1u32 = any() {}
+    if let 1f32 = any() {}
+    if let 1.0 = any() {}
+    if let true = any() {}
+}
+"#, true),
+        @r###"
+    [18; 29) '{ loop {} }': T
+    [20; 27) 'loop {}': !
+    [25; 27) '{}': ()
+    [38; 39) 'x': &i32
+    [47; 209) '{     ...) {} }': ()
+    [53; 76) 'if let...y() {}': ()
+    [60; 65) '"foo"': &str
+    [60; 65) '"foo"': &str
+    [68; 71) 'any': fn any<&str>() -> &str
+    [68; 73) 'any()': &str
+    [74; 76) '{}': ()
+    [81; 100) 'if let...y() {}': ()
+    [88; 89) '1': i32
+    [88; 89) '1': i32
+    [92; 95) 'any': fn any<i32>() -> i32
+    [92; 97) 'any()': i32
+    [98; 100) '{}': ()
+    [105; 127) 'if let...y() {}': ()
+    [112; 116) '1u32': u32
+    [112; 116) '1u32': u32
+    [119; 122) 'any': fn any<u32>() -> u32
+    [119; 124) 'any()': u32
+    [125; 127) '{}': ()
+    [132; 154) 'if let...y() {}': ()
+    [139; 143) '1f32': f32
+    [139; 143) '1f32': f32
+    [146; 149) 'any': fn any<f32>() -> f32
+    [146; 151) 'any()': f32
+    [152; 154) '{}': ()
+    [159; 180) 'if let...y() {}': ()
+    [166; 169) '1.0': f64
+    [166; 169) '1.0': f64
+    [172; 175) 'any': fn any<f64>() -> f64
+    [172; 177) 'any()': f64
+    [178; 180) '{}': ()
+    [185; 207) 'if let...y() {}': ()
+    [192; 196) 'true': bool
+    [192; 196) 'true': bool
+    [199; 202) 'any': fn any<bool>() -> bool
+    [199; 204) 'any()': bool
+    [205; 207) '{}': ()
+    "###
+    );
+}
+#[test]
+fn infer_range_pattern() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn test(x: &i32) {
+    if let 1..76 = 2u32 {}
+    if let 1..=76 = 2u32 {}
+}
+"#, true),
+        @r###"
+    [9; 10) 'x': &i32
+    [18; 76) '{     ...2 {} }': ()
+    [24; 46) 'if let...u32 {}': ()
+    [31; 36) '1..76': u32
+    [39; 43) '2u32': u32
+    [44; 46) '{}': ()
+    [51; 74) 'if let...u32 {}': ()
+    [58; 64) '1..=76': u32
+    [67; 71) '2u32': u32
+    [72; 74) '{}': ()
+    "###
+    );
+}
+#[test]
 fn infer_pattern_match_ergonomics() {
    assert_snapshot!(
        infer(r#"
@@ -212,6 +296,7 @@ fn test() {
    [59; 62) 'arr': [f64; _]
    [73; 81) '[1.0, a]': [f64; _]
    [74; 77) '1.0': f64
+    [74; 77) '1.0': f64
    [79; 80) 'a': f64
    [85; 111) '{     ...     }': ()
    [99; 100) 'a': f64
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index a02e3ee05..2ee9b8f10 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -206,7 +206,8 @@ pub fn compute() {
    [24; 106) 'match ...     }': ()
    [30; 37) 'nope!()': {unknown}
    [48; 94) 'SizeSk...tail }': {unknown}
-    [82; 86) 'true': {unknown}
+    [82; 86) 'true': bool
+    [82; 86) 'true': bool
    [88; 92) 'tail': {unknown}
    [98; 100) '{}': ()
    "###
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index c140bd513..a600b947d 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -948,6 +948,7 @@ fn foo() {
    [165; 247) 'match ...     }': i32
    [171; 175) 'true': bool
    [186; 190) 'true': bool
+    [186; 190) 'true': bool
    [194; 195) '3': i32
    [205; 206) '_': bool
    [210; 241) '{     ...     }': !
@@ -956,6 +957,7 @@ fn foo() {
    [263; 320) 'match ...     }': i32
    [269; 273) 'true': bool
    [284; 288) 'true': bool
+    [284; 288) 'true': bool
    [292; 293) '4': i32
    [303; 304) '_': bool
    [308; 314) 'return': !
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index c1b6e1ddc..b50cda06f 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -75,7 +75,7 @@ pub type Target = Idx<TargetData>;
 #[derive(Debug, Clone)]
 pub struct PackageData {
-    pub id: String,
+    pub version: String,
    pub name: String,
    pub manifest: PathBuf,
    pub targets: Vec<Target>,
@@ -174,14 +174,15 @@ impl CargoWorkspace {
        let ws_members = &meta.workspace_members;
        for meta_pkg in meta.packages {
-            let cargo_metadata::Package { id, edition, name, manifest_path, .. } = meta_pkg;
+            let cargo_metadata::Package { id, edition, name, manifest_path, version, .. } =
+                meta_pkg;
            let is_member = ws_members.contains(&id);
            let edition = edition
                .parse::<Edition>()
                .with_context(|| format!("Failed to parse edition {}", edition))?;
            let pkg = packages.alloc(PackageData {
                name,
-                id: id.to_string(),
+                version: version.to_string(),
                manifest: manifest_path,
                targets: Vec::new(),
                is_member,
@@ -256,7 +257,7 @@ impl CargoWorkspace {
        if self.is_unique(&*package.name) {
            package.name.clone()
        } else {
-            package.id.clone()
+            format!("{}:{}", package.name, package.version)
        }
    }
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index dd9c80691..0ab64a1e0 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -62,16 +62,16 @@ pub struct PackageRoot {
    /// Is a member of the current workspace
    is_member: bool,
 }
 impl PackageRoot {
-    pub fn new(path: PathBuf, is_member: bool) -> PackageRoot {
+    pub fn new_member(path: PathBuf) -> PackageRoot {
-        PackageRoot { path, is_member }
+        Self { path, is_member: true }
    }
+    pub fn new_non_member(path: PathBuf) -> PackageRoot {
-    pub fn path(&self) -> &PathBuf {
+        Self { path, is_member: false }
+    }
+    pub fn path(&self) -> &Path {
        &self.path
    }
    pub fn is_member(&self) -> bool {
        self.is_member
    }
@@ -130,70 +130,45 @@ impl ProjectWorkspace {
    pub fn to_roots(&self) -> Vec<PackageRoot> {
        match self {
            ProjectWorkspace::Json { project } => {
-                let mut roots = Vec::with_capacity(project.roots.len());
+                project.roots.iter().map(|r| PackageRoot::new_member(r.path.clone())).collect()
-                for root in &project.roots {
-                    roots.push(PackageRoot::new(root.path.clone(), true));
-                }
-                roots
-            }
-            ProjectWorkspace::Cargo { cargo, sysroot } => {
-                let mut roots = Vec::with_capacity(cargo.packages().len() + sysroot.crates().len());
-                for pkg in cargo.packages() {
-                    let root = cargo[pkg].root().to_path_buf();
-                    let member = cargo[pkg].is_member;
-                    roots.push(PackageRoot::new(root, member));
-                }
-                for krate in sysroot.crates() {
-                    roots.push(PackageRoot::new(sysroot[krate].root_dir().to_path_buf(), false))
-                }
-                roots
            }
+            ProjectWorkspace::Cargo { cargo, sysroot } => cargo
+                .packages()
+                .map(|pkg| PackageRoot {
+                    path: cargo[pkg].root().to_path_buf(),
+                    is_member: cargo[pkg].is_member,
+                })
+                .chain(sysroot.crates().map(|krate| {
+                    PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf())
+                }))
+                .collect(),
        }
    }
    pub fn out_dirs(&self) -> Vec<PathBuf> {
        match self {
            ProjectWorkspace::Json { project } => {
-                let mut out_dirs = Vec::with_capacity(project.crates.len());
+                project.crates.iter().filter_map(|krate| krate.out_dir.as_ref()).cloned().collect()
-                for krate in &project.crates {
-                    if let Some(out_dir) = &krate.out_dir {
-                        out_dirs.push(out_dir.to_path_buf());
-                    }
-                }
-                out_dirs
            }
-            ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => {
+            ProjectWorkspace::Cargo { cargo, sysroot: _ } => {
-                let mut out_dirs = Vec::with_capacity(cargo.packages().len());
+                cargo.packages().filter_map(|pkg| cargo[pkg].out_dir.as_ref()).cloned().collect()
-                for pkg in cargo.packages() {
-                    if let Some(out_dir) = &cargo[pkg].out_dir {
-                        out_dirs.push(out_dir.to_path_buf());
-                    }
-                }
-                out_dirs
            }
        }
    }
    pub fn proc_macro_dylib_paths(&self) -> Vec<PathBuf> {
        match self {
-            ProjectWorkspace::Json { project } => {
+            ProjectWorkspace::Json { project } => project
-                let mut proc_macro_dylib_paths = Vec::with_capacity(project.crates.len());
+                .crates
-                for krate in &project.crates {
+                .iter()
-                    if let Some(out_dir) = &krate.proc_macro_dylib_path {
+                .filter_map(|krate| krate.proc_macro_dylib_path.as_ref())
-                        proc_macro_dylib_paths.push(out_dir.to_path_buf());
+                .cloned()
-                    }
+                .collect(),
-                }
+            ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => cargo
-                proc_macro_dylib_paths
+                .packages()
-            }
+                .filter_map(|pkg| cargo[pkg].proc_macro_dylib_path.as_ref())
-            ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => {
+                .cloned()
-                let mut proc_macro_dylib_paths = Vec::with_capacity(cargo.packages().len());
+                .collect(),
-                for pkg in cargo.packages() {
-                    if let Some(dylib_path) = &cargo[pkg].proc_macro_dylib_path {
-                        proc_macro_dylib_paths.push(dylib_path.to_path_buf());
-                    }
-                }
-                proc_macro_dylib_paths
-            }
        }
    }
@@ -216,10 +191,12 @@ impl ProjectWorkspace {
        let mut crate_graph = CrateGraph::default();
        match self {
            ProjectWorkspace::Json { project } => {
-                let mut crates = FxHashMap::default();
+                let crates: FxHashMap<_, _> = project
-                for (id, krate) in project.crates.iter().enumerate() {
+                    .crates
-                    let crate_id = json_project::CrateId(id);
+                    .iter()
-                    if let Some(file_id) = load(&krate.root_module) {
+                    .enumerate()
+                    .filter_map(|(seq_index, krate)| {
+                        let file_id = load(&krate.root_module)?;
                        let edition = match krate.edition {
                            json_project::Edition::Edition2015 => Edition::Edition2015,
                            json_project::Edition::Edition2018 => Edition::Edition2018,
@@ -249,8 +226,8 @@ impl ProjectWorkspace {
                            .clone()
                            .map(|it| proc_macro_client.by_dylib_path(&it));
                        // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
-                        crates.insert(
+                        Some((
-                            crate_id,
+                            json_project::CrateId(seq_index),
                            crate_graph.add_crate_root(
                                file_id,
                                edition,
@@ -261,9 +238,9 @@ impl ProjectWorkspace {
                                extern_source,
                                proc_macro.unwrap_or_default(),
                            ),
-                        );
+                        ))
-                    }
+                    })
-                }
+                    .collect();
                for (id, krate) in project.crates.iter().enumerate() {
                    for dep in &krate.deps {
@@ -287,9 +264,11 @@ impl ProjectWorkspace {
                }
            }
            ProjectWorkspace::Cargo { cargo, sysroot } => {
-                let mut sysroot_crates = FxHashMap::default();
+                let sysroot_crates: FxHashMap<_, _> = sysroot
-                for krate in sysroot.crates() {
+                    .crates()
-                    if let Some(file_id) = load(&sysroot[krate].root) {
+                    .filter_map(|krate| {
+                        let file_id = load(&sysroot[krate].root)?;
                        // Crates from sysroot have `cfg(test)` disabled
                        let cfg_options = {
                            let mut opts = default_cfg_options.clone();
@@ -300,22 +279,22 @@ impl ProjectWorkspace {
                        let env = Env::default();
                        let extern_source = ExternSource::default();
                        let proc_macro = vec![];
+                        let crate_name = CrateName::new(&sysroot[krate].name)
+                            .expect("Sysroot crate names should not contain dashes");
                        let crate_id = crate_graph.add_crate_root(
                            file_id,
                            Edition::Edition2018,
-                            Some(
+                            Some(crate_name),
-                                CrateName::new(&sysroot[krate].name)
-                                    .expect("Sysroot crate names should not contain dashes"),
-                            ),
                            cfg_options,
                            env,
                            extern_source,
                            proc_macro,
                        );
-                        sysroot_crates.insert(krate, crate_id);
+                        Some((krate, crate_id))
-                    }
+                    })
-                }
+                    .collect();
                for from in sysroot.crates() {
                    for &to in sysroot[from].deps.iter() {
                        let name = &sysroot[to].name;
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index dbb9c8a9b..f39559e9e 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -22,7 +22,8 @@ pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path {
 pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path {
    path_from_text(&format!("{}::{}", qual, segment))
 }
-fn path_from_text(text: &str) -> ast::Path {
+pub fn path_from_text(text: &str) -> ast::Path {
    ast_from_text(text)
 }
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 2c0bde920..69133e4e4 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -36,8 +36,7 @@ pub(crate) fn load_cargo(
    extern_dirs.extend(ws.out_dirs());
    let mut project_roots = ws.to_roots();
-    project_roots
+    project_roots.extend(extern_dirs.iter().cloned().map(PackageRoot::new_non_member));
-        .extend(extern_dirs.iter().map(|path| PackageRoot::new(path.to_path_buf(), false)));
    let (sender, receiver) = unbounded();
    let sender = Box::new(move |t| sender.send(t).unwrap());
@@ -46,7 +45,7 @@ pub(crate) fn load_cargo(
            .iter()
            .map(|pkg_root| {
                RootEntry::new(
-                    pkg_root.path().clone(),
+                    pkg_root.path().to_owned(),
                    RustPackageFilterBuilder::default()
                        .set_member(pkg_root.is_member())
                        .into_vfs_filter(),
@@ -58,12 +57,12 @@ pub(crate) fn load_cargo(
    );
    let source_roots = roots
-        .iter()
+        .into_iter()
-        .map(|&vfs_root| {
+        .map(|vfs_root| {
            let source_root_id = vfs_root_to_id(vfs_root);
            let project_root = project_roots
                .iter()
-                .find(|it| it.path() == &vfs.root2path(vfs_root))
+                .find(|it| it.path() == vfs.root2path(vfs_root))
                .unwrap()
                .clone();
            (source_root_id, project_root)
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 3c8f55f1e..04f5bb473 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -16,21 +16,33 @@ use serde::Deserialize;
 #[derive(Debug, Clone)]
 pub struct Config {
    pub client_caps: ClientCapsConfig,
-    pub publish_decorations: bool,
+    pub with_sysroot: bool,
    pub publish_diagnostics: bool,
+    pub lru_capacity: Option<usize>,
+    pub proc_macro_srv: Option<String>,
+    pub files: FilesConfig,
    pub notifications: NotificationsConfig,
+    pub cargo: CargoConfig,
+    pub rustfmt: RustfmtConfig,
+    pub check: Option<FlycheckConfig>,
    pub inlay_hints: InlayHintsConfig,
    pub completion: CompletionConfig,
    pub call_info_full: bool,
-    pub rustfmt: RustfmtConfig,
+}
-    pub check: Option<FlycheckConfig>,
-    pub vscode_lldb: bool,
+#[derive(Debug, Clone)]
-    pub proc_macro_srv: Option<String>,
+pub struct FilesConfig {
-    pub lru_capacity: Option<usize>,
+    pub watcher: FilesWatcher,
-    pub use_client_watching: bool,
+    pub exclude: Vec<String>,
-    pub exclude_globs: Vec<String>,
+}
-    pub cargo: CargoConfig,
-    pub with_sysroot: bool,
+#[derive(Debug, Clone)]
+pub enum FilesWatcher {
+    Client,
+    Notify,
 }
 #[derive(Debug, Clone)]
@@ -60,13 +72,26 @@ pub struct ClientCapsConfig {
 impl Default for Config {
    fn default() -> Self {
        Config {
-            publish_decorations: false,
+            client_caps: ClientCapsConfig::default(),
+            with_sysroot: true,
            publish_diagnostics: true,
+            lru_capacity: None,
+            proc_macro_srv: None,
+            files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
            notifications: NotificationsConfig {
                workspace_loaded: true,
                cargo_toml_not_found: true,
            },
-            client_caps: ClientCapsConfig::default(),
+            cargo: CargoConfig::default(),
+            rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
+            check: Some(FlycheckConfig::CargoCommand {
+                command: "check".to_string(),
+                all_targets: true,
+                extra_args: Vec::new(),
+            }),
            inlay_hints: InlayHintsConfig {
                type_hints: true,
                parameter_hints: true,
@@ -79,19 +104,6 @@ impl Default for Config {
                add_call_argument_snippets: true,
            },
            call_info_full: true,
-            rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
-            check: Some(FlycheckConfig::CargoCommand {
-                command: "check".to_string(),
-                all_targets: true,
-                extra_args: Vec::new(),
-            }),
-            vscode_lldb: false,
-            proc_macro_srv: None,
-            lru_capacity: None,
-            use_client_watching: false,
-            exclude_globs: Vec::new(),
-            cargo: CargoConfig::default(),
-            with_sysroot: true,
        }
    }
 }
@@ -105,46 +117,61 @@ impl Config {
        *self = Default::default();
        self.client_caps = client_caps;
-        set(value, "/publishDecorations", &mut self.publish_decorations);
+        set(value, "/withSysroot", &mut self.with_sysroot);
-        set(value, "/excludeGlobs", &mut self.exclude_globs);
+        set(value, "/featureFlags/lsp.diagnostics", &mut self.publish_diagnostics);
-        set(value, "/useClientWatching", &mut self.use_client_watching);
        set(value, "/lruCapacity", &mut self.lru_capacity);
+        if let Some(watcher) =  get::<String>(value, "/files/watcher") {
-        set(value, "/inlayHintsType", &mut self.inlay_hints.type_hints);
+            self.files.watcher = match watcher.as_str() {
-        set(value, "/inlayHintsParameter", &mut self.inlay_hints.parameter_hints);
+                "client" => FilesWatcher::Client,
-        set(value, "/inlayHintsChaining", &mut self.inlay_hints.chaining_hints);
+                "notify"| _ => FilesWatcher::Notify,
-        set(value, "/inlayHintsMaxLength", &mut self.inlay_hints.max_length);
+            }
+        }
-        if let Some(false) = get(value, "cargo_watch_enable") {
+        set(value, "/notifications/workspaceLoaded", &mut self.notifications.workspace_loaded);
+        set(value, "/notifications/cargoTomlNotFound", &mut self.notifications.cargo_toml_not_found);
+        set(value, "/cargo/noDefaultFeatures", &mut self.cargo.no_default_features);
+        set(value, "/cargo/allFeatures", &mut self.cargo.all_features);
+        set(value, "/cargo/features", &mut self.cargo.features);
+        set(value, "/cargo/loadOutDirsFromCheck", &mut self.cargo.load_out_dirs_from_check);
+        if let Some(mut args) = get::<Vec<String>>(value, "/rustfmt/overrideCommand") {
+            if !args.is_empty() {
+                let command = args.remove(0);
+                self.rustfmt = RustfmtConfig::CustomCommand {
+                    command,
+                    args,
+                }
+            }
+        } else if let RustfmtConfig::Rustfmt { extra_args } = &mut self.rustfmt {
+            set(value, "/rustfmt/extraArgs", extra_args);
+        }
+        if let Some(false) = get(value, "/checkOnSave/enable") {
            self.check = None
        } else {
-            if let Some(FlycheckConfig::CargoCommand { command, extra_args, all_targets }) = &mut self.check
+            if let Some(mut args) = get::<Vec<String>>(value, "/checkOnSave/overrideCommand") {
+                if !args.is_empty() {
+                    let command = args.remove(0);
+                    self.check = Some(FlycheckConfig::CustomCommand {
+                        command,
+                        args,
+                    })
+                }
+            } else if let Some(FlycheckConfig::CargoCommand { command, extra_args, all_targets }) = &mut self.check
            {
-                set(value, "/cargoWatchArgs", extra_args);
+                set(value, "/checkOnSave/extraArgs", extra_args);
-                set(value, "/cargoWatchCommand", command);
+                set(value, "/checkOnSave/command", command);
-                set(value, "/cargoWatchAllTargets", all_targets);
+                set(value, "/checkOnSave/allTargets", all_targets);
            }
        };
-        set(value, "/withSysroot", &mut self.with_sysroot);
+        set(value, "/inlayHints/typeHints", &mut self.inlay_hints.type_hints);
-        if let RustfmtConfig::Rustfmt { extra_args } = &mut self.rustfmt {
+        set(value, "/inlayHints/parameterHints", &mut self.inlay_hints.parameter_hints);
-            set(value, "/rustfmtArgs", extra_args);
+        set(value, "/inlayHints/chainingHints", &mut self.inlay_hints.chaining_hints);
-        }
+        set(value, "/inlayHints/maxLength", &mut self.inlay_hints.max_length);
+        set(value, "/completion/postfix/enable", &mut self.completion.enable_postfix_completions);
-        set(value, "/cargoFeatures/noDefaultFeatures", &mut self.cargo.no_default_features);
+        set(value, "/completion/addCallParenthesis", &mut self.completion.add_call_parenthesis);
-        set(value, "/cargoFeatures/allFeatures", &mut self.cargo.all_features);
+        set(value, "/completion/addCallArgumentSnippets", &mut self.completion.add_call_argument_snippets);
-        set(value, "/cargoFeatures/features", &mut self.cargo.features);
+        set(value, "/callInfo/full", &mut self.call_info_full);
-        set(value, "/cargoFeatures/loadOutDirsFromCheck", &mut self.cargo.load_out_dirs_from_check);
-        set(value, "/vscodeLldb", &mut self.vscode_lldb);
-        set(value, "/featureFlags/lsp.diagnostics", &mut self.publish_diagnostics);
-        set(value, "/featureFlags/notifications.workspace-loaded", &mut self.notifications.workspace_loaded);
-        set(value, "/featureFlags/notifications.cargo-toml-not-found", &mut self.notifications.cargo_toml_not_found);
-        set(value, "/featureFlags/completion.enable-postfix", &mut self.completion.enable_postfix_completions);
-        set(value, "/featureFlags/completion.insertion.add-call-parenthesis", &mut self.completion.add_call_parenthesis);
-        set(value, "/featureFlags/completion.insertion.add-argument-snippets", &mut self.completion.add_call_argument_snippets);
-        set(value, "/featureFlags/call-info.full", &mut self.call_info_full);
        log::info!("Config::update() = {:#?}", self);
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 45ae0ad9d..8d1429196 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -23,6 +23,7 @@ use lsp_types::{
 use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckTask};
 use ra_ide::{Canceled, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
+use ra_project_model::{PackageRoot, ProjectWorkspace};
 use ra_vfs::{VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
 use rustc_hash::FxHashSet;
@@ -30,7 +31,7 @@ use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
 use crate::{
-    config::Config,
+    config::{Config, FilesWatcher},
    diagnostics::DiagnosticTask,
    main_loop::{
        pending_requests::{PendingRequest, PendingRequests},
@@ -40,7 +41,6 @@ use crate::{
    world::{WorldSnapshot, WorldState},
    Result,
 };
-use req::ConfigurationParams;
 #[derive(Debug)]
 pub struct LspError {
@@ -122,17 +122,18 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
        };
        let globs = config
-            .exclude_globs
+            .files
+            .exclude
            .iter()
            .map(|glob| crate::vfs_glob::Glob::new(glob))
            .collect::<std::result::Result<Vec<_>, _>>()?;
-        if config.use_client_watching {
+        if let FilesWatcher::Client = config.files.watcher {
            let registration_options = req::DidChangeWatchedFilesRegistrationOptions {
                watchers: workspaces
                    .iter()
-                    .flat_map(|ws| ws.to_roots())
+                    .flat_map(ProjectWorkspace::to_roots)
-                    .filter(|root| root.is_member())
+                    .filter(PackageRoot::is_member)
                    .map(|root| format!("{}/**/*.rs", root.path().display()))
                    .map(|glob_pattern| req::FileSystemWatcher { glob_pattern, kind: None })
                    .collect(),
@@ -153,7 +154,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
            workspaces,
            config.lru_capacity,
            &globs,
-            Watch(!config.use_client_watching),
+            Watch(matches!(config.files.watcher, FilesWatcher::Notify)),
            config,
        )
    };
@@ -250,9 +251,7 @@ impl fmt::Debug for Event {
                }
            }
            Event::Task(Task::Notify(not)) => {
-                if notification_is::<req::PublishDecorations>(not)
+                if notification_is::<req::PublishDiagnostics>(not) {
-                    || notification_is::<req::PublishDiagnostics>(not)
-                {
                    return debug_verbose_not(not, f);
                }
            }
@@ -427,7 +426,6 @@ fn loop_turn(
        update_file_notifications_on_threadpool(
            pool,
            world_state.snapshot(),
-            world_state.config.publish_decorations,
            task_sender.clone(),
            loop_state.subscriptions.subscriptions(),
        )
@@ -508,7 +506,6 @@ fn on_request(
        .on::<req::GotoTypeDefinition>(handlers::handle_goto_type_definition)?
        .on::<req::ParentModule>(handlers::handle_parent_module)?
        .on::<req::Runnables>(handlers::handle_runnables)?
-        .on::<req::DecorationsRequest>(handlers::handle_decorations)?
        .on::<req::Completion>(handlers::handle_completion)?
        .on::<req::CodeActionRequest>(handlers::handle_code_action)?
        .on::<req::CodeLensRequest>(handlers::handle_code_lens)?
@@ -611,7 +608,12 @@ fn on_notification(
            let request_id = loop_state.next_request_id();
            let request = request_new::<req::WorkspaceConfiguration>(
                request_id.clone(),
-                ConfigurationParams::default(),
+                req::ConfigurationParams {
+                    items: vec![req::ConfigurationItem {
+                        scope_uri: None,
+                        section: Some("rust-analyzer".to_string()),
+                    }],
+                },
            );
            msg_sender.send(request.into())?;
            loop_state.configuration_request_id = Some(request_id);
@@ -884,15 +886,13 @@ where
 fn update_file_notifications_on_threadpool(
    pool: &ThreadPool,
    world: WorldSnapshot,
-    publish_decorations: bool,
    task_sender: Sender<Task>,
    subscriptions: Vec<FileId>,
 ) {
    log::trace!("updating notifications for {:?}", subscriptions);
-    let publish_diagnostics = world.config.publish_diagnostics;
+    if world.config.publish_diagnostics {
-    pool.execute(move || {
+        pool.execute(move || {
-        for file_id in subscriptions {
+            for file_id in subscriptions {
-            if publish_diagnostics {
                match handlers::publish_diagnostics(&world, file_id) {
                    Err(e) => {
                        if !is_canceled(&e) {
@@ -904,21 +904,8 @@ fn update_file_notifications_on_threadpool(
                    }
                }
            }
-            if publish_decorations {
+        })
-                match handlers::publish_decorations(&world, file_id) {
+    }
-                    Err(e) => {
-                        if !is_canceled(&e) {
-                            log::error!("failed to compute decorations: {:?}", e);
-                        }
-                    }
-                    Ok(params) => {
-                        let not = notification_new::<req::PublishDecorations>(params);
-                        task_sender.send(Task::Notify(not)).unwrap();
-                    }
-                }
-            }
-        }
-    });
 }
 pub fn show_message(typ: req::MessageType, message: impl Into<String>, sender: &Sender<Message>) {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 23e48c089..b207f0764 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -38,7 +38,7 @@ use crate::{
    },
    diagnostics::DiagnosticTask,
    from_json,
-    req::{self, Decoration, InlayHint, InlayHintsParams},
+    req::{self, InlayHint, InlayHintsParams},
    semantic_tokens::SemanticTokensBuilder,
    world::WorldSnapshot,
    LspError, Result,
@@ -389,15 +389,6 @@ pub fn handle_runnables(
    Ok(res)
 }
-pub fn handle_decorations(
-    world: WorldSnapshot,
-    params: TextDocumentIdentifier,
-) -> Result<Vec<Decoration>> {
-    let _p = profile("handle_decorations");
-    let file_id = params.try_conv_with(&world)?;
-    highlight(&world, file_id)
-}
 pub fn handle_completion(
    world: WorldSnapshot,
    params: req::CompletionParams,
@@ -819,23 +810,21 @@ pub fn handle_code_lens(
        };
        lenses.push(lens);
-        if world.config.vscode_lldb {
+        if r.args[0] == "run" {
-            if r.args[0] == "run" {
+            r.args[0] = "build".into();
-                r.args[0] = "build".into();
+        } else {
-            } else {
+            r.args.push("--no-run".into());
-                r.args.push("--no-run".into());
-            }
-            let debug_lens = CodeLens {
-                range: r.range,
-                command: Some(Command {
-                    title: "Debug".into(),
-                    command: "rust-analyzer.debugSingle".into(),
-                    arguments: Some(vec![to_value(r).unwrap()]),
-                }),
-                data: None,
-            };
-            lenses.push(debug_lens);
        }
+        let debug_lens = CodeLens {
+            range: r.range,
+            command: Some(Command {
+                title: "Debug".into(),
+                command: "rust-analyzer.debugSingle".into(),
+                arguments: Some(vec![to_value(r).unwrap()]),
+            }),
+            data: None,
+        };
+        lenses.push(debug_lens);
    }
    // Handle impls
@@ -970,15 +959,6 @@ pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<Dia
    Ok(DiagnosticTask::SetNative(file_id, diagnostics))
 }
-pub fn publish_decorations(
-    world: &WorldSnapshot,
-    file_id: FileId,
-) -> Result<req::PublishDecorationsParams> {
-    let _p = profile("publish_decorations");
-    let uri = world.file_id_to_uri(file_id)?;
-    Ok(req::PublishDecorationsParams { uri, decorations: highlight(&world, file_id)? })
-}
 fn to_lsp_runnable(
    world: &WorldSnapshot,
    file_id: FileId,
@@ -1008,21 +988,6 @@ fn to_lsp_runnable(
    })
 }
-fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>> {
-    let line_index = world.analysis().file_line_index(file_id)?;
-    let res = world
-        .analysis()
-        .highlight(file_id)?
-        .into_iter()
-        .map(|h| Decoration {
-            range: h.range.conv_with(&line_index),
-            tag: h.highlight.to_string(),
-            binding_hash: h.binding_hash.map(|x| x.to_string()),
-        })
-        .collect();
-    Ok(res)
-}
 pub fn handle_inlay_hints(
    world: WorldSnapshot,
    params: InlayHintsParams,
diff --git a/crates/rust-analyzer/src/main_loop/subscriptions.rs b/crates/rust-analyzer/src/main_loop/subscriptions.rs
index bee6437cf..2c76418be 100644
--- a/crates/rust-analyzer/src/main_loop/subscriptions.rs
+++ b/crates/rust-analyzer/src/main_loop/subscriptions.rs
@@ -17,6 +17,6 @@ impl Subscriptions {
        self.subs.remove(&file_id);
    }
    pub(crate) fn subscriptions(&self) -> Vec<FileId> {
-        self.subs.iter().cloned().collect()
+        self.subs.iter().copied().collect()
    }
 }
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index 994f0ed61..b8b627e28 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -1,13 +1,13 @@
 //! Defines `rust-analyzer` specific custom messages.
-use lsp_types::{Location, Position, Range, TextDocumentIdentifier, Url};
+use lsp_types::{Location, Position, Range, TextDocumentIdentifier};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 pub use lsp_types::{
    notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
-    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationParams, DiagnosticTag,
+    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationItem, ConfigurationParams,
-    DidChangeConfigurationParams, DidChangeWatchedFilesParams,
+    DiagnosticTag, DidChangeConfigurationParams, DidChangeWatchedFilesParams,
    DidChangeWatchedFilesRegistrationOptions, DocumentOnTypeFormattingParams, DocumentSymbolParams,
    DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
    PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,
@@ -86,36 +86,6 @@ pub struct FindMatchingBraceParams {
    pub offsets: Vec<Position>,
 }
-pub enum DecorationsRequest {}
-impl Request for DecorationsRequest {
-    type Params = TextDocumentIdentifier;
-    type Result = Vec<Decoration>;
-    const METHOD: &'static str = "rust-analyzer/decorationsRequest";
-}
-pub enum PublishDecorations {}
-impl Notification for PublishDecorations {
-    type Params = PublishDecorationsParams;
-    const METHOD: &'static str = "rust-analyzer/publishDecorations";
-}
-#[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PublishDecorationsParams {
-    pub uri: Url,
-    pub decorations: Vec<Decoration>,
-}
-#[derive(Deserialize, Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Decoration {
-    pub range: Range,
-    pub tag: String,
-    pub binding_hash: Option<String>,
-}
 pub enum ParentModule {}
 impl Request for ParentModule {
diff --git a/crates/rust-analyzer/src/vfs_glob.rs b/crates/rust-analyzer/src/vfs_glob.rs
index 91b33f94e..ff37a7008 100644
--- a/crates/rust-analyzer/src/vfs_glob.rs
+++ b/crates/rust-analyzer/src/vfs_glob.rs
@@ -29,10 +29,14 @@ impl RustPackageFilterBuilder {
        self.is_member = is_member;
        self
    }
-    pub fn exclude(mut self, glob: Glob) -> RustPackageFilterBuilder {
-        self.exclude.add(glob);
+    pub fn exclude(mut self, globs: impl IntoIterator<Item = Glob>) -> RustPackageFilterBuilder {
+        for glob in globs.into_iter() {
+            self.exclude.add(glob);
+        }
        self
    }
    pub fn into_vfs_filter(self) -> Box<dyn Filter> {
        let RustPackageFilterBuilder { is_member, mut exclude } = self;
        for &glob in ALWAYS_IGNORED {
@@ -87,7 +91,7 @@ fn test_globs() {
    let filter = RustPackageFilterBuilder::default()
        .set_member(true)
-        .exclude(Glob::new("src/llvm-project/**").unwrap())
+        .exclude(std::iter::once(Glob::new("src/llvm-project/**").unwrap()))
        .into_vfs_filter();
    assert!(!filter.include_dir(RelativePath::new("src/llvm-project/clang")));
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 5674f42ef..365f57d8c 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -87,44 +87,35 @@ impl WorldState {
    ) -> WorldState {
        let mut change = AnalysisChange::new();
-        let mut roots = Vec::new();
+        let extern_dirs: FxHashSet<_> =
-        roots.extend(folder_roots.iter().map(|path| {
+            workspaces.iter().flat_map(ProjectWorkspace::out_dirs).collect();
-            let mut filter = RustPackageFilterBuilder::default().set_member(true);
-            for glob in exclude_globs.iter() {
+        let roots: Vec<_> = {
-                filter = filter.exclude(glob.clone());
+            let create_filter = |is_member| {
-            }
+                RustPackageFilterBuilder::default()
-            RootEntry::new(path.clone(), filter.into_vfs_filter())
+                    .set_member(is_member)
-        }));
+                    .exclude(exclude_globs.iter().cloned())
-        for ws in workspaces.iter() {
+                    .into_vfs_filter()
-            roots.extend(ws.to_roots().into_iter().map(|pkg_root| {
+            };
-                let mut filter =
+            folder_roots
-                    RustPackageFilterBuilder::default().set_member(pkg_root.is_member());
+                .iter()
-                for glob in exclude_globs.iter() {
+                .map(|path| RootEntry::new(path.clone(), create_filter(true)))
-                    filter = filter.exclude(glob.clone());
+                .chain(workspaces.iter().flat_map(ProjectWorkspace::to_roots).map(|pkg_root| {
-                }
+                    RootEntry::new(pkg_root.path().to_owned(), create_filter(pkg_root.is_member()))
-                RootEntry::new(pkg_root.path().clone(), filter.into_vfs_filter())
+                }))
-            }));
+                .chain(
-        }
+                    extern_dirs
+                        .iter()
-        let mut extern_dirs = FxHashSet::default();
+                        .map(|path| RootEntry::new(path.to_owned(), create_filter(false))),
-        for ws in workspaces.iter() {
+                )
-            extern_dirs.extend(ws.out_dirs());
+                .collect()
-        }
+        };
-        let mut extern_source_roots = FxHashMap::default();
-        roots.extend(extern_dirs.iter().map(|path| {
-            let mut filter = RustPackageFilterBuilder::default().set_member(false);
-            for glob in exclude_globs.iter() {
-                filter = filter.exclude(glob.clone());
-            }
-            RootEntry::new(PathBuf::from(&path), filter.into_vfs_filter())
-        }));
        let (task_sender, task_receiver) = unbounded();
        let task_sender = Box::new(move |t| task_sender.send(t).unwrap());
        let (mut vfs, vfs_roots) = Vfs::new(roots, task_sender, watch);
+        let mut extern_source_roots = FxHashMap::default();
        for r in vfs_roots {
            let vfs_root_path = vfs.root2path(r);
            let is_local = folder_roots.iter().any(|it| vfs_root_path.starts_with(it));
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 8d7e18010..f230dc1db 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -155,6 +155,16 @@ There's also two VS Code commands which might be of interest:
 * `Rust Analyzer: Syntax Tree` shows syntax tree of the current file/selection.
+  You can hover over syntax nodes in the opened text file to see the appropriate
+  rust code that it refers to and the rust editor will also highlight the proper
+  text range.
+  If you press <kbd>Ctrl</kbd> (i.e. trigger goto definition) in the inspected
+  Rust source file the syntax tree read-only editor should scroll to and select the
+  appropriate syntax node token.
+  ![demo](https://user-images.githubusercontent.com/36276403/78225773-6636a480-74d3-11ea-9d9f-1c9d42da03b0.png)
 # Profiling
 We have a built-in hierarchical profiler, you can enable it by using `RA_PROFILE` env-var:
diff --git a/docs/user/features.md b/docs/user/features.md
index 8aeec2e81..56d2969fd 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -81,12 +81,6 @@ Join selected lines into one, smartly fixing up whitespace and trailing commas.
 Shows the parse tree of the current file. It exists mostly for debugging
 rust-analyzer itself.
-You can hover over syntax nodes in the opened text file to see the appropriate
-rust code that it refers to and the rust editor will also highlight the proper
-text range.
-<img src="https://user-images.githubusercontent.com/36276403/78043783-7425e180-737c-11ea-8653-b02b773c5aa1.png" alt="demo" height="200px" >
 #### Expand Macro Recursively
 Shows the full macro expansion of the macro at current cursor.
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 2d8b432a7..d5dec8fc5 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -459,12 +459,6 @@
            "integrity": "sha1-OjYof1A05pnnV3kBBSwubJQlFjE=",
            "dev": true
        },
-        "didyoumean": {
-            "version": "1.2.1",
-            "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.1.tgz",
-            "integrity": "sha1-6S7f2tplN9SE1zwBcv0eugxJdv8=",
-            "dev": true
-        },
        "doctrine": {
            "version": "3.0.0",
            "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
@@ -1043,6 +1037,12 @@
            "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.1.tgz",
            "integrity": "sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w=="
        },
+        "leven": {
+            "version": "3.1.0",
+            "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+            "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+            "dev": true
+        },
        "levn": {
            "version": "0.3.0",
            "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
@@ -1088,16 +1088,24 @@
            }
        },
        "markdown-it": {
-            "version": "8.4.2",
+            "version": "10.0.0",
-            "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-8.4.2.tgz",
+            "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-10.0.0.tgz",
-            "integrity": "sha512-GcRz3AWTqSUphY3vsUqQSFMbgR38a4Lh3GWlHRh/7MRwz8mcu9n2IO7HOh+bXHrR9kOPDl5RNCaEsrneb+xhHQ==",
+            "integrity": "sha512-YWOP1j7UbDNz+TumYP1kpwnP0aEa711cJjrAQrzd0UXlbJfc5aAq0F/PZHjiioqDC1NKgvIMX+o+9Bk7yuM2dg==",
            "dev": true,
            "requires": {
                "argparse": "^1.0.7",
-                "entities": "~1.1.1",
+                "entities": "~2.0.0",
                "linkify-it": "^2.0.0",
                "mdurl": "^1.0.1",
                "uc.micro": "^1.0.5"
+            },
+            "dependencies": {
+                "entities": {
+                    "version": "2.0.0",
+                    "resolved": "https://registry.npmjs.org/entities/-/entities-2.0.0.tgz",
+                    "integrity": "sha512-D9f7V0JSRwIxlRI2mjMqufDrRDnx8p+eEOz7aUM9SuvF8gsBzra0/6tbjl1m8eQHrZlYj6PxqE00hZ1SAIKPLw==",
+                    "dev": true
+                }
            }
        },
        "mdurl": {
@@ -1723,9 +1731,9 @@
            "dev": true
        },
        "vsce": {
-            "version": "1.74.0",
+            "version": "1.75.0",
-            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.74.0.tgz",
+            "resolved": "https://registry.npmjs.org/vsce/-/vsce-1.75.0.tgz",
-            "integrity": "sha512-8zWM9bZBNn9my40kkxAxdY4nhb9ADfazXsyDgx1thbRaLPbmPTlmqQ55vCAyWYFEi6XbJv8w599vzVUqsU1gHg==",
+            "integrity": "sha512-qyAQTmolxKWc9bV1z0yBTSH4WEIWhDueBJMKB0GUFD6lM4MiaU1zJ9BtzekUORZu094YeNSKz0RmVVuxfqPq0g==",
            "dev": true,
            "requires": {
                "azure-devops-node-api": "^7.2.0",
@@ -1733,10 +1741,10 @@
                "cheerio": "^1.0.0-rc.1",
                "commander": "^2.8.1",
                "denodeify": "^1.2.1",
-                "didyoumean": "^1.2.1",
                "glob": "^7.0.6",
+                "leven": "^3.1.0",
                "lodash": "^4.17.15",
-                "markdown-it": "^8.3.1",
+                "markdown-it": "^10.0.0",
                "mime": "^1.3.4",
                "minimatch": "^3.0.3",
                "osenv": "^0.1.3",
diff --git a/editors/code/package.json b/editors/code/package.json
index 146b696e9..88b7ee86a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -49,7 +49,7 @@
        "tslib": "^1.11.1",
        "typescript": "^3.8.3",
        "typescript-formatter": "^7.2.2",
-        "vsce": "^1.74.0"
+        "vsce": "^1.75.0"
    },
    "activationEvents": [
        "onLanguage:rust",
@@ -177,91 +177,70 @@
            "type": "object",
            "title": "Rust Analyzer",
            "properties": {
-                "rust-analyzer.highlighting.semanticTokens": {
+                "rust-analyzer.diagnostics.enable": {
                    "type": "boolean",
-                    "default": false,
+                    "default": true,
-                    "description": "Use proposed semantic tokens API for syntax highlighting"
+                    "markdownDescription": "Whether to show native rust-analyzer diagnostics."
-                },
-                "rust-analyzer.highlightingOn": {
-                    "type": "boolean",
-                    "default": false,
-                    "description": "Highlight Rust code (overrides built-in syntax highlighting)"
-                },
-                "rust-analyzer.rainbowHighlightingOn": {
-                    "type": "boolean",
-                    "default": false,
-                    "description": "When highlighting Rust code, use a unique color per identifier"
                },
-                "rust-analyzer.featureFlags": {
+                "rust-analyzer.lruCapacity": {
-                    "type": "object",
+                    "type": [
-                    "default": {},
+                        "null",
-                    "description": "Fine grained feature flags to disable annoying features",
+                        "integer"
-                    "properties": {
+                    ],
-                        "lsp.diagnostics": {
+                    "default": null,
-                            "type": "boolean",
+                    "minimum": 0,
-                            "markdownDescription": "Whether to show diagnostics from `cargo check`"
+                    "exclusiveMinimum": true,
-                        },
+                    "description": "Number of syntax trees rust-analyzer keeps in memory."
-                        "completion.insertion.add-call-parenthesis": {
-                            "type": "boolean",
-                            "description": "Whether to add parenthesis when completing functions"
-                        },
-                        "completion.insertion.add-argument-snippets": {
-                            "type": "boolean",
-                            "description": "Whether to add argument snippets when completing functions"
-                        },
-                        "completion.enable-postfix": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
-                        },
-                        "call-info.full": {
-                            "type": "boolean",
-                            "description": "Show function name and docs in parameter hints"
-                        },
-                        "notifications.workspace-loaded": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show `workspace loaded` message"
-                        },
-                        "notifications.cargo-toml-not-found": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
-                        }
-                    }
                },
-                "rust-analyzer.updates.channel": {
+                "rust-analyzer.files.watcher": {
                    "type": "string",
                    "enum": [
-                        "stable",
+                        "client",
-                        "nightly"
+                        "notify"
-                    ],
-                    "default": "stable",
-                    "markdownEnumDescriptions": [
-                        "`\"stable\"` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general",
-                        "`\"nightly\"` updates are shipped daily (extension updates automatically by downloading artifacts directly from GitHub), they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**"
                    ],
-                    "markdownDescription": "Choose `\"nightly\"` updates to get the latest features and bug fixes every day. While `\"stable\"` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs"
+                    "default": "client",
+                    "description": "Controls file watching implementation."
                },
-                "rust-analyzer.updates.askBeforeDownload": {
+                "rust-analyzer.files.exclude": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [],
+                    "description": "Paths to exclude from analysis."
+                },
+                "rust-analyzer.notifications.workspaceLoaded": {
                    "type": "boolean",
-                    "default": true,
+                    "markdownDescription": "Whether to show `workspace loaded` message."
-                    "description": "Whether to ask for permission before downloading any files from the Internet"
                },
-                "rust-analyzer.serverPath": {
+                "rust-analyzer.notifications.cargoTomlNotFound": {
-                    "type": [
+                    "type": "boolean",
-                        "null",
+                    "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
-                        "string"
+                },
-                    ],
+                "rust-analyzer.cargo.noDefaultFeatures": {
-                    "default": null,
+                    "type": "boolean",
-                    "description": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then \"rust-analyzer.updates.channel\" setting is not used"
+                    "default": false,
+                    "markdownDescription": "Do not activate the `default` feature"
+                },
+                "rust-analyzer.cargo.allFeatures": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Activate all available features"
                },
-                "rust-analyzer.excludeGlobs": {
+                "rust-analyzer.cargo.features": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
                    "default": [],
-                    "description": "Paths to exclude from analysis"
+                    "description": "List of features to activate"
+                },
+                "rust-analyzer.cargo.loadOutDirsFromCheck": {
+                    "type": "boolean",
+                    "default": false,
+                    "markdownDescription": "Run `cargo check` on startup to get the correct value for package OUT_DIRs"
                },
-                "rust-analyzer.rustfmtArgs": {
+                "rust-analyzer.rustfmt.extraArgs": {
                    "type": "array",
                    "items": {
                        "type": "string"
@@ -269,64 +248,42 @@
                    "default": [],
                    "description": "Additional arguments to rustfmt"
                },
-                "rust-analyzer.useClientWatching": {
+                "rust-analyzer.rustfmt.overrideCommand": {
-                    "type": "boolean",
+                    "type": "array",
-                    "default": true,
+                    "items": {
-                    "description": "client provided file watching instead of notify watching."
+                        "type": "string"
+                    },
+                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for formatting."
                },
-                "rust-analyzer.cargo-watch.enable": {
+                "rust-analyzer.checkOnSave.enable": {
                    "type": "boolean",
                    "default": true,
-                    "markdownDescription": "Run specified `cargo-watch` command for diagnostics on save"
+                    "markdownDescription": "Run specified `cargo check` command for diagnostics on save"
                },
-                "rust-analyzer.cargo-watch.arguments": {
+                "rust-analyzer.checkOnSave.extraArgs": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
-                    "markdownDescription": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
+                    "markdownDescription": "Extra arguments for `cargo check`",
                    "default": []
                },
-                "rust-analyzer.cargo-watch.command": {
+                "rust-analyzer.checkOnSave.command": {
                    "type": "string",
-                    "markdownDescription": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
+                    "default": "check",
-                    "default": "check"
+                    "markdownDescription": "Cargo command to use for `cargo check`"
                },
-                "rust-analyzer.cargo-watch.allTargets": {
+                "rust-analyzer.checkOnSave.overrideCommand": {
-                    "type": "boolean",
+                    "type": "array",
-                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)",
+                    "items": {
-                    "default": true
+                        "type": "string"
-                },
+                    },
-                "rust-analyzer.trace.server": {
+                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for checking. The command should include `--message=format=json` or similar option."
-                    "type": "string",
-                    "scope": "window",
-                    "enum": [
-                        "off",
-                        "messages",
-                        "verbose"
-                    ],
-                    "enumDescriptions": [
-                        "No traces",
-                        "Error only",
-                        "Full log"
-                    ],
-                    "default": "off",
-                    "description": "Trace requests to the rust-analyzer"
                },
-                "rust-analyzer.trace.extension": {
+                "rust-analyzer.checkOnSave.allTargets": {
-                    "description": "Enable logging of VS Code extensions itself",
                    "type": "boolean",
-                    "default": false
+                    "default": true,
-                },
+                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)"
-                "rust-analyzer.lruCapacity": {
-                    "type": [
-                        "null",
-                        "integer"
-                    ],
-                    "default": null,
-                    "minimum": 0,
-                    "exclusiveMinimum": true,
-                    "description": "Number of syntax trees rust-analyzer keeps in memory"
                },
                "rust-analyzer.inlayHints.typeHints": {
                    "type": "boolean",
@@ -353,28 +310,76 @@
                    "exclusiveMinimum": true,
                    "description": "Maximum length for inlay hints"
                },
-                "rust-analyzer.cargoFeatures.noDefaultFeatures": {
+                "rust-analyzer.completion.addCallParenthesis": {
                    "type": "boolean",
-                    "default": false,
+                    "default": true,
-                    "markdownDescription": "Do not activate the `default` feature"
+                    "description": "Whether to add parenthesis when completing functions"
                },
-                "rust-analyzer.cargoFeatures.allFeatures": {
+                "rust-analyzer.completion.addCallArgumentSnippets": {
                    "type": "boolean",
                    "default": true,
-                    "description": "Activate all available features"
+                    "description": "Whether to add argument snippets when completing functions"
                },
-                "rust-analyzer.cargoFeatures.features": {
+                "rust-analyzer.completion.postfix.enable": {
-                    "type": "array",
+                    "type": "boolean",
-                    "items": {
+                    "default": true,
-                        "type": "string"
+                    "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
-                    },
-                    "default": [],
-                    "description": "List of features to activate"
                },
-                "rust-analyzer.cargoFeatures.loadOutDirsFromCheck": {
+                "rust-analyzer.callInfo.full": {
+                    "type": "boolean",
+                    "description": "Show function name and docs in parameter hints"
+                },
+                "rust-analyzer.highlighting.semanticTokens": {
                    "type": "boolean",
                    "default": false,
-                    "markdownDescription": "Run `cargo check` on startup to get the correct value for package OUT_DIRs"
+                    "description": "Use proposed semantic tokens API for syntax highlighting"
+                },
+                "rust-analyzer.updates.channel": {
+                    "type": "string",
+                    "enum": [
+                        "stable",
+                        "nightly"
+                    ],
+                    "default": "stable",
+                    "markdownEnumDescriptions": [
+                        "`\"stable\"` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general",
+                        "`\"nightly\"` updates are shipped daily (extension updates automatically by downloading artifacts directly from GitHub), they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**"
+                    ],
+                    "markdownDescription": "Choose `\"nightly\"` updates to get the latest features and bug fixes every day. While `\"stable\"` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs"
+                },
+                "rust-analyzer.updates.askBeforeDownload": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to ask for permission before downloading any files from the Internet"
+                },
+                "rust-analyzer.serverPath": {
+                    "type": [
+                        "null",
+                        "string"
+                    ],
+                    "default": null,
+                    "description": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then \"rust-analyzer.updates.channel\" setting is not used"
+                },
+                "rust-analyzer.trace.server": {
+                    "type": "string",
+                    "scope": "window",
+                    "enum": [
+                        "off",
+                        "messages",
+                        "verbose"
+                    ],
+                    "enumDescriptions": [
+                        "No traces",
+                        "Error only",
+                        "Full log"
+                    ],
+                    "default": "off",
+                    "description": "Trace requests to the rust-analyzer"
+                },
+                "rust-analyzer.trace.extension": {
+                    "description": "Enable logging of VS Code extensions itself",
+                    "type": "boolean",
+                    "default": false
                }
            }
        },
@@ -411,6 +416,21 @@
                ]
            }
        ],
+        "languages": [
+            {
+                "id": "ra_syntax_tree",
+                "extensions": [
+                    ".rast"
+                ]
+            }
+        ],
+        "grammars": [
+            {
+                "language": "ra_syntax_tree",
+                "scopeName": "source.ra_syntax_tree",
+                "path": "ra_syntax_tree.tmGrammar.json"
+            }
+        ],
        "problemMatchers": [
            {
                "name": "rustc",
@@ -450,6 +470,15 @@
                    "light": "#747474",
                    "highContrast": "#BEBEBE"
                }
+            },
+            {
+                "id": "rust_analyzer.syntaxTreeBorder",
+                "description": "Color of the border displayed in the Rust source code for the selected syntax node (see \"Show Syntax Tree\" command)",
+                "defaults": {
+                    "dark": "#ffffff",
+                    "light": "#b700ff",
+                    "highContrast": "#b700ff"
+                }
            }
        ],
        "semanticTokenTypes": [
@@ -492,65 +521,34 @@
                "description": "Style for unsafe operations"
            }
        ],
-        "semanticTokenStyleDefaults": [
+        "semanticTokenScopes": [
            {
-                "selector": "attribute",
+                "language": "rust",
-                "scope": [
+                "scopes": {
-                    "meta.attribute"
+                    "attribute": [
-                ]
+                        "meta.attribute"
-            },
+                    ],
-            {
+                    "builtinType": [
-                "selector": "builtinType",
+                        "support.type.primitive"
-                "scope": [
+                    ],
-                    "support.type.primitive"
+                    "lifetime": [
-                ]
+                        "entity.name.lifetime.rust"
-            },
+                    ],
-            {
+                    "typeAlias": [
-                "selector": "lifetime",
+                        "entity.name.typeAlias"
-                "scope": [
+                    ],
-                    "entity.name.lifetime.rust"
+                    "union": [
-                ]
+                        "entity.name.union"
-            },
+                    ],
-            {
+                    "keyword.unsafe": [
-                "selector": "typeAlias",
+                        "keyword.other.unsafe"
-                "scope": [
+                    ],
-                    "entity.name.typeAlias"
+                    "keyword.control": [
-                ]
+                        "keyword.control"
-            },
+                    ],
-            {
+                    "variable.constant": [
-                "selector": "union",
+                        "entity.name.constant"
-                "scope": [
+                    ]
-                    "entity.name.union"
-                ]
-            },
-            {
-                "selector": "keyword.unsafe",
-                "scope": [
-                    "keyword.other.unsafe"
-                ]
-            },
-            {
-                "selector": "keyword.control",
-                "scope": [
-                    "keyword.control"
-                ]
-            },
-            {
-                "selector": "variable.constant",
-                "scope": [
-                    "entity.name.constant"
-                ]
-            },
-            {
-                "selector": "*.mutable",
-                "light": {
-                    "fontStyle": "underline"
-                },
-                "dark": {
-                    "fontStyle": "underline"
-                },
-                "highContrast": {
-                    "fontStyle": "underline"
                }
            }
        ]
diff --git a/editors/code/ra_syntax_tree.tmGrammar.json b/editors/code/ra_syntax_tree.tmGrammar.json
new file mode 100644
index 000000000..0d72a3e36
--- /dev/null
+++ b/editors/code/ra_syntax_tree.tmGrammar.json
@@ -0,0 +1,31 @@
+{
+    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+    "scopeName": "source.ra_syntax_tree",
+    "patterns": [
+        { "include": "#node_type" },
+        { "include": "#node_range_index" },
+        { "include": "#token_text" }
+    ],
+    "repository": {
+        "node_type": {
+            "match": "^\\s*([A-Z_]+?)@",
+            "captures": {
+                "1": {
+                    "name": "entity.name.class"
+                }
+            }
+        },
+        "node_range_index": {
+            "match": "\\d+",
+            "name": "constant.numeric"
+        },
+        "token_text": {
+            "match": "\".+\"",
+            "name": "string"
+        }
+    },
+    "fileTypes": [
+        "rast"
+    ]
+}
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index f909f8db2..3b1d00bca 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -5,31 +5,6 @@ import { Config } from './config';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
-export function configToServerOptions(config: Config) {
-    return {
-        publishDecorations: !config.highlightingSemanticTokens,
-        lruCapacity: config.lruCapacity,
-        inlayHintsType: config.inlayHints.typeHints,
-        inlayHintsParameter: config.inlayHints.parameterHints,
-        inlayHintsChaining: config.inlayHints.chainingHints,
-        inlayHintsMaxLength: config.inlayHints.maxLength,
-        cargoWatchEnable: config.cargoWatchOptions.enable,
-        cargoWatchArgs: config.cargoWatchOptions.arguments,
-        cargoWatchCommand: config.cargoWatchOptions.command,
-        cargoWatchAllTargets: config.cargoWatchOptions.allTargets,
-        excludeGlobs: config.excludeGlobs,
-        useClientWatching: config.useClientWatching,
-        featureFlags: config.featureFlags,
-        withSysroot: config.withSysroot,
-        cargoFeatures: config.cargoFeatures,
-        rustfmtArgs: config.rustfmtArgs,
-        vscodeLldb: vscode.extensions.getExtension("vadimcn.vscode-lldb") != null,
-    };
-}
 export async function createClient(config: Config, serverPath: string, cwd: string): Promise<lc.LanguageClient> {
    // '.' Is the fallback if no folder is open
    // TODO?: Workspace folders support Uri's (eg: file://test.txt).
@@ -49,7 +24,7 @@ export async function createClient(config: Config, serverPath: string, cwd: stri
    const clientOptions: lc.LanguageClientOptions = {
        documentSelector: [{ scheme: 'file', language: 'rust' }],
-        initializationOptions: configToServerOptions(config),
+        initializationOptions: vscode.workspace.getConfiguration("rust-analyzer"),
        traceOutputChannel,
        middleware: {
            // Workaround for https://github.com/microsoft/vscode-languageserver-node/issues/576
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 357155163..2635a1440 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -66,6 +66,10 @@ export function debugSingle(ctx: Ctx): Cmd {
    return async (config: ra.Runnable) => {
        const editor = ctx.activeRustEditor;
        if (!editor) return;
+        if (!vscode.extensions.getExtension("vadimcn.vscode-lldb")) {
+            vscode.window.showErrorMessage("Install `vadimcn.vscode-lldb` extension for debugging");
+            return;
+        }
        const debugConfig = {
            type: "lldb",
diff --git a/editors/code/src/commands/syntax_tree.ts b/editors/code/src/commands/syntax_tree.ts
index 996c7a716..b7a397414 100644
--- a/editors/code/src/commands/syntax_tree.ts
+++ b/editors/code/src/commands/syntax_tree.ts
@@ -15,6 +15,9 @@ export function syntaxTree(ctx: Ctx): Cmd {
    void new AstInspector(ctx);
    ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider(AST_FILE_SCHEME, tdcp));
+    ctx.pushCleanup(vscode.languages.setLanguageConfiguration("ra_syntax_tree", {
+        brackets: [["[", ")"]],
+    }));
    return async () => {
        const editor = vscode.window.activeTextEditor;
@@ -36,7 +39,7 @@ export function syntaxTree(ctx: Ctx): Cmd {
 }
 class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
-    readonly uri = vscode.Uri.parse('rust-analyzer://syntaxtree');
+    readonly uri = vscode.Uri.parse('rust-analyzer://syntaxtree/tree.rast');
    readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
@@ -79,16 +82,41 @@ class TextDocumentContentProvider implements vscode.TextDocumentContentProvider
 // FIXME: consider implementing this via the Tree View API?
 // https://code.visualstudio.com/api/extension-guides/tree-view
-class AstInspector implements vscode.HoverProvider, Disposable {
+class AstInspector implements vscode.HoverProvider, vscode.DefinitionProvider, Disposable {
-    private static readonly astDecorationType = vscode.window.createTextEditorDecorationType({
+    private readonly astDecorationType = vscode.window.createTextEditorDecorationType({
-        fontStyle: "normal",
+        borderColor: new vscode.ThemeColor('rust_analyzer.syntaxTreeBorder'),
-        border: "#ffffff 1px solid",
+        borderStyle: "solid",
+        borderWidth: "2px",
    });
    private rustEditor: undefined | RustEditor;
+    // Lazy rust token range -> syntax tree file range.
+    private readonly rust2Ast = new Lazy(() => {
+        const astEditor = this.findAstTextEditor();
+        if (!this.rustEditor || !astEditor) return undefined;
+        const buf: [vscode.Range, vscode.Range][] = [];
+        for (let i = 0; i < astEditor.document.lineCount; ++i) {
+            const astLine = astEditor.document.lineAt(i);
+            // Heuristically look for nodes with quoted text (which are token nodes)
+            const isTokenNode = astLine.text.lastIndexOf('"') >= 0;
+            if (!isTokenNode) continue;
+            const rustRange = this.parseRustTextRange(this.rustEditor.document, astLine.text);
+            if (!rustRange) continue;
+            buf.push([rustRange, this.findAstNodeRange(astLine)]);
+        }
+        return buf;
+    });
    constructor(ctx: Ctx) {
        ctx.pushCleanup(vscode.languages.registerHoverProvider({ scheme: AST_FILE_SCHEME }, this));
+        ctx.pushCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));
        vscode.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, ctx.subscriptions);
+        vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);
        vscode.window.onDidChangeVisibleTextEditors(this.onDidChangeVisibleTextEditors, this, ctx.subscriptions);
        ctx.pushCleanup(this);
@@ -97,6 +125,12 @@ class AstInspector implements vscode.HoverProvider, Disposable {
        this.setRustEditor(undefined);
    }
+    private onDidChangeTextDocument(event: vscode.TextDocumentChangeEvent) {
+        if (this.rustEditor && event.document.uri.toString() === this.rustEditor.document.uri.toString()) {
+            this.rust2Ast.reset();
+        }
+    }
    private onDidCloseTextDocument(doc: vscode.TextDocument) {
        if (this.rustEditor && doc.uri.toString() === this.rustEditor.document.uri.toString()) {
            this.setRustEditor(undefined);
@@ -104,38 +138,67 @@ class AstInspector implements vscode.HoverProvider, Disposable {
    }
    private onDidChangeVisibleTextEditors(editors: vscode.TextEditor[]) {
-        if (editors.every(suspect => suspect.document.uri.scheme !== AST_FILE_SCHEME)) {
+        if (!this.findAstTextEditor()) {
            this.setRustEditor(undefined);
            return;
        }
        this.setRustEditor(editors.find(isRustEditor));
    }
+    private findAstTextEditor(): undefined | vscode.TextEditor {
+        return vscode.window.visibleTextEditors.find(it => it.document.uri.scheme === AST_FILE_SCHEME);
+    }
    private setRustEditor(newRustEditor: undefined | RustEditor) {
-        if (newRustEditor !== this.rustEditor) {
+        if (this.rustEditor && this.rustEditor !== newRustEditor) {
-            this.rustEditor?.setDecorations(AstInspector.astDecorationType, []);
+            this.rustEditor.setDecorations(this.astDecorationType, []);
+            this.rust2Ast.reset();
        }
        this.rustEditor = newRustEditor;
    }
+    // additional positional params are omitted
+    provideDefinition(doc: vscode.TextDocument, pos: vscode.Position): vscode.ProviderResult<vscode.DefinitionLink[]> {
+        if (!this.rustEditor || doc.uri.toString() !== this.rustEditor.document.uri.toString()) return;
+        const astEditor = this.findAstTextEditor();
+        if (!astEditor) return;
+        const rust2AstRanges = this.rust2Ast.get()?.find(([rustRange, _]) => rustRange.contains(pos));
+        if (!rust2AstRanges) return;
+        const [rustFileRange, astFileRange] = rust2AstRanges;
+        astEditor.revealRange(astFileRange);
+        astEditor.selection = new vscode.Selection(astFileRange.start, astFileRange.end);
+        return [{
+            targetRange: astFileRange,
+            targetUri: astEditor.document.uri,
+            originSelectionRange: rustFileRange,
+            targetSelectionRange: astFileRange,
+        }];
+    }
+    // additional positional params are omitted
    provideHover(doc: vscode.TextDocument, hoverPosition: vscode.Position): vscode.ProviderResult<vscode.Hover> {
        if (!this.rustEditor) return;
-        const astTextLine = doc.lineAt(hoverPosition.line);
+        const astFileLine = doc.lineAt(hoverPosition.line);
-        const rustTextRange = this.parseRustTextRange(this.rustEditor.document, astTextLine.text);
+        const rustFileRange = this.parseRustTextRange(this.rustEditor.document, astFileLine.text);
-        if (!rustTextRange) return;
+        if (!rustFileRange) return;
-        this.rustEditor.setDecorations(AstInspector.astDecorationType, [rustTextRange]);
+        this.rustEditor.setDecorations(this.astDecorationType, [rustFileRange]);
-        this.rustEditor.revealRange(rustTextRange);
+        this.rustEditor.revealRange(rustFileRange);
-        const rustSourceCode = this.rustEditor.document.getText(rustTextRange);
+        const rustSourceCode = this.rustEditor.document.getText(rustFileRange);
-        const astTextRange = this.findAstRange(astTextLine);
+        const astFileRange = this.findAstNodeRange(astFileLine);
-        return new vscode.Hover(["```rust\n" + rustSourceCode + "\n```"], astTextRange);
+        return new vscode.Hover(["```rust\n" + rustSourceCode + "\n```"], astFileRange);
    }
-    private findAstRange(astLine: vscode.TextLine) {
+    private findAstNodeRange(astLine: vscode.TextLine) {
        const lineOffset = astLine.range.start;
        const begin = lineOffset.translate(undefined, astLine.firstNonWhitespaceCharacterIndex);
        const end = lineOffset.translate(undefined, astLine.text.trimEnd().length);
@@ -151,3 +214,17 @@ class AstInspector implements vscode.HoverProvider, Disposable {
        return new vscode.Range(begin, end);
    }
 }
+class Lazy<T> {
+    val: undefined | T;
+    constructor(private readonly compute: () => undefined | T) { }
+    get() {
+        return this.val ?? (this.val = this.compute());
+    }
+    reset() {
+        this.val = undefined;
+    }
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 501997fef..1f45f1de0 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -11,9 +11,8 @@ export class Config {
    private readonly rootSection = "rust-analyzer";
    private readonly requiresReloadOpts = [
        "serverPath",
-        "cargoFeatures",
+        "cargo",
-        "excludeGlobs",
+        "files",
-        "useClientWatching",
        "highlighting",
        "updates.channel",
    ]
@@ -71,19 +70,8 @@ export class Config {
    get channel() { return this.cfg.get<UpdatesChannel>("updates.channel")!; }
    get askBeforeDownload() { return this.cfg.get<boolean>("updates.askBeforeDownload")!; }
    get highlightingSemanticTokens() { return this.cfg.get<boolean>("highlighting.semanticTokens")!; }
-    get highlightingOn() { return this.cfg.get<boolean>("highlightingOn")!; }
-    get rainbowHighlightingOn() { return this.cfg.get<boolean>("rainbowHighlightingOn")!; }
-    get lruCapacity() { return this.cfg.get<null | number>("lruCapacity")!; }
-    get excludeGlobs() { return this.cfg.get<string[]>("excludeGlobs")!; }
-    get useClientWatching() { return this.cfg.get<boolean>("useClientWatching")!; }
-    get featureFlags() { return this.cfg.get<Record<string, boolean>>("featureFlags")!; }
-    get rustfmtArgs() { return this.cfg.get<string[]>("rustfmtArgs")!; }
-    get loadOutDirsFromCheck() { return this.cfg.get<boolean>("loadOutDirsFromCheck")!; }
    get traceExtension() { return this.cfg.get<boolean>("trace.extension")!; }
-    // for internal use
-    get withSysroot() { return this.cfg.get<boolean>("withSysroot", true)!; }
    get inlayHints() {
        return {
            typeHints: this.cfg.get<boolean>("inlayHints.typeHints")!,
@@ -93,21 +81,9 @@ export class Config {
        };
    }
-    get cargoWatchOptions() {
+    get checkOnSave() {
-        return {
-            enable: this.cfg.get<boolean>("cargo-watch.enable")!,
-            arguments: this.cfg.get<string[]>("cargo-watch.arguments")!,
-            allTargets: this.cfg.get<boolean>("cargo-watch.allTargets")!,
-            command: this.cfg.get<string>("cargo-watch.command")!,
-        };
-    }
-    get cargoFeatures() {
        return {
-            noDefaultFeatures: this.cfg.get<boolean>("cargoFeatures.noDefaultFeatures")!,
+            command: this.cfg.get<string>("checkOnSave.command")!,
-            allFeatures: this.cfg.get<boolean>("cargoFeatures.allFeatures")!,
-            features: this.cfg.get<string[]>("cargoFeatures.features")!,
-            loadOutDirsFromCheck: this.cfg.get<boolean>("cargoFeatures.loadOutDirsFromCheck")!,
        };
    }
 }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 86b5f3629..bd1c3de07 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -2,7 +2,7 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import { Config } from './config';
-import { createClient, configToServerOptions } from './client';
+import { createClient } from './client';
 import { isRustEditor, RustEditor } from './util';
 export class Ctx {
@@ -25,7 +25,6 @@ export class Ctx {
        const res = new Ctx(config, extCtx, client, serverPath);
        res.pushCleanup(client.start());
        await client.onReady();
-        client.onRequest('workspace/configuration', _ => [configToServerOptions(config)]);
        return res;
    }
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
deleted file mode 100644
index ea2dfc0e3..000000000
--- a/editors/code/src/highlighting.ts
+++ /dev/null
@@ -1,255 +0,0 @@
-import * as vscode from 'vscode';
-import * as ra from './rust-analyzer-api';
-import { ColorTheme, TextMateRuleSettings } from './color_theme';
-import { Ctx } from './ctx';
-import { sendRequestWithRetry, isRustDocument } from './util';
-export function activateHighlighting(ctx: Ctx) {
-    const highlighter = new Highlighter(ctx);
-    ctx.client.onNotification(ra.publishDecorations, params => {
-        if (!ctx.config.highlightingOn) return;
-        const targetEditor = vscode.window.visibleTextEditors.find(
-            editor => {
-                const unescapedUri = unescape(
-                    editor.document.uri.toString(),
-                );
-                // Unescaped URI looks like:
-                // file:///c:/Workspace/ra-test/src/main.rs
-                return unescapedUri === params.uri;
-            },
-        );
-        if (!targetEditor) return;
-        highlighter.setHighlights(targetEditor, params.decorations);
-    });
-    vscode.workspace.onDidChangeConfiguration(
-        _ => highlighter.removeHighlights(),
-        null,
-        ctx.subscriptions,
-    );
-    vscode.window.onDidChangeActiveTextEditor(
-        async (editor: vscode.TextEditor | undefined) => {
-            if (!editor || !isRustDocument(editor.document)) return;
-            if (!ctx.config.highlightingOn) return;
-            const client = ctx.client;
-            if (!client) return;
-            const decorations = await sendRequestWithRetry(
-                client,
-                ra.decorationsRequest,
-                { uri: editor.document.uri.toString() },
-            );
-            highlighter.setHighlights(editor, decorations);
-        },
-        null,
-        ctx.subscriptions,
-    );
-}
-// Based on this HSL-based color generator: https://gist.github.com/bendc/76c48ce53299e6078a76
-function fancify(seed: string, shade: 'light' | 'dark') {
-    const random = randomU32Numbers(hashString(seed));
-    const randomInt = (min: number, max: number) => {
-        return Math.abs(random()) % (max - min + 1) + min;
-    };
-    const h = randomInt(0, 360);
-    const s = randomInt(42, 98);
-    const l = shade === 'light' ? randomInt(15, 40) : randomInt(40, 90);
-    return `hsl(${h},${s}%,${l}%)`;
-}
-class Highlighter {
-    private ctx: Ctx;
-    private decorations: Map<
-        string,
-        vscode.TextEditorDecorationType
-    > | null = null;
-    constructor(ctx: Ctx) {
-        this.ctx = ctx;
-    }
-    public removeHighlights() {
-        if (this.decorations == null) {
-            return;
-        }
-        // Decorations are removed when the object is disposed
-        for (const decoration of this.decorations.values()) {
-            decoration.dispose();
-        }
-        this.decorations = null;
-    }
-    public setHighlights(editor: vscode.TextEditor, highlights: ra.Decoration[]) {
-        const client = this.ctx.client;
-        if (!client) return;
-        // Initialize decorations if necessary
-        //
-        // Note: decoration objects need to be kept around so we can dispose them
-        // if the user disables syntax highlighting
-        if (this.decorations == null) {
-            this.decorations = initDecorations();
-        }
-        const byTag: Map<string, vscode.Range[]> = new Map();
-        const colorfulIdents: Map<
-            string,
-            [vscode.Range[], boolean]
-        > = new Map();
-        const rainbowTime = this.ctx.config.rainbowHighlightingOn;
-        for (const tag of this.decorations.keys()) {
-            byTag.set(tag, []);
-        }
-        for (const d of highlights) {
-            if (!byTag.get(d.tag)) {
-                continue;
-            }
-            if (rainbowTime && d.bindingHash) {
-                if (!colorfulIdents.has(d.bindingHash)) {
-                    const mut = d.tag.endsWith('.mut');
-                    colorfulIdents.set(d.bindingHash, [[], mut]);
-                }
-                colorfulIdents
-                    .get(d.bindingHash)![0]
-                    .push(
-                        client.protocol2CodeConverter.asRange(d.range),
-                    );
-            } else {
-                byTag
-                    .get(d.tag)!
-                    .push(
-                        client.protocol2CodeConverter.asRange(d.range),
-                    );
-            }
-        }
-        for (const tag of byTag.keys()) {
-            const dec = this.decorations.get(
-                tag,
-            ) as vscode.TextEditorDecorationType;
-            const ranges = byTag.get(tag)!;
-            editor.setDecorations(dec, ranges);
-        }
-        for (const [hash, [ranges, mut]] of colorfulIdents.entries()) {
-            const textDecoration = mut ? 'underline' : undefined;
-            const dec = vscode.window.createTextEditorDecorationType({
-                light: { color: fancify(hash, 'light'), textDecoration },
-                dark: { color: fancify(hash, 'dark'), textDecoration },
-            });
-            editor.setDecorations(dec, ranges);
-        }
-    }
-}
-function initDecorations(): Map<string, vscode.TextEditorDecorationType> {
-    const theme = ColorTheme.load();
-    const res = new Map();
-    TAG_TO_SCOPES.forEach((scopes, tag) => {
-        // We are going to axe this soon, so don't try to detect unknown tags.
-        // Users should switch to the new semantic tokens implementation.
-        if (!scopes) return;
-        const rule = theme.lookup(scopes);
-        const decor = createDecorationFromTextmate(rule);
-        res.set(tag, decor);
-    });
-    return res;
-}
-function createDecorationFromTextmate(
-    themeStyle: TextMateRuleSettings,
-): vscode.TextEditorDecorationType {
-    const decorationOptions: vscode.DecorationRenderOptions = {};
-    decorationOptions.rangeBehavior = vscode.DecorationRangeBehavior.OpenOpen;
-    if (themeStyle.foreground) {
-        decorationOptions.color = themeStyle.foreground;
-    }
-    if (themeStyle.background) {
-        decorationOptions.backgroundColor = themeStyle.background;
-    }
-    if (themeStyle.fontStyle) {
-        const parts: string[] = themeStyle.fontStyle.split(' ');
-        parts.forEach(part => {
-            switch (part) {
-                case 'italic':
-                    decorationOptions.fontStyle = 'italic';
-                    break;
-                case 'bold':
-                    decorationOptions.fontWeight = 'bold';
-                    break;
-                case 'underline':
-                    decorationOptions.textDecoration = 'underline';
-                    break;
-                default:
-                    break;
-            }
-        });
-    }
-    return vscode.window.createTextEditorDecorationType(decorationOptions);
-}
-// sync with tags from `syntax_highlighting.rs`.
-const TAG_TO_SCOPES = new Map<string, string[]>([
-    ["field", ["entity.name.field"]],
-    ["function", ["entity.name.function"]],
-    ["module", ["entity.name.module"]],
-    ["constant", ["entity.name.constant"]],
-    ["macro", ["entity.name.macro"]],
-    ["variable", ["variable"]],
-    ["variable.mutable", ["variable", "meta.mutable"]],
-    ["type", ["entity.name.type"]],
-    ["type.builtin", ["entity.name.type", "support.type.primitive"]],
-    ["type.self", ["entity.name.type.parameter.self"]],
-    ["type.param", ["entity.name.type.parameter", "entity.name.type.param.rust"]],
-    ["type.lifetime", ["entity.name.type.lifetime", "entity.name.lifetime.rust"]],
-    ["literal.byte", ["constant.character.byte"]],
-    ["literal.char", ["constant.character.rust"]],
-    ["numeric_literal", ["constant.numeric"]],
-    ["comment", ["comment"]],
-    ["string_literal", ["string.quoted"]],
-    ["attribute", ["meta.attribute.rust"]],
-    ["keyword", ["keyword"]],
-    ["keyword.unsafe", ["keyword.other.unsafe"]],
-    ["keyword.control", ["keyword.control"]],
-]);
-function randomU32Numbers(seed: number) {
-    let random = seed | 0;
-    return () => {
-        random ^= random << 13;
-        random ^= random >> 17;
-        random ^= random << 5;
-        random |= 0;
-        return random;
-    };
-}
-function hashString(str: string): number {
-    let res = 0;
-    for (let i = 0; i < str.length; ++i) {
-        const c = str.codePointAt(i)!;
-        res = (res * 31 + c) & ~0;
-    }
-    return res;
-}
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 7ba16120c..4f3b89f44 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -7,7 +7,6 @@ import * as commands from './commands';
 import { activateInlayHints } from './inlay_hints';
 import { activateStatusDisplay } from './status_display';
 import { Ctx } from './ctx';
-import { activateHighlighting } from './highlighting';
 import { Config, NIGHTLY_TAG } from './config';
 import { log, assert } from './util';
 import { PersistentState } from './persistent_state';
@@ -97,9 +96,6 @@ export async function activate(context: vscode.ExtensionContext) {
    activateStatusDisplay(ctx);
-    if (!ctx.config.highlightingSemanticTokens) {
-        activateHighlighting(ctx);
-    }
    activateInlayHints(ctx);
    vscode.workspace.onDidChangeConfiguration(
diff --git a/editors/code/src/status_display.ts b/editors/code/src/status_display.ts
index 0f5f6ef99..f9cadc8a2 100644
--- a/editors/code/src/status_display.ts
+++ b/editors/code/src/status_display.ts
@@ -7,7 +7,7 @@ import { Ctx } from './ctx';
 const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 export function activateStatusDisplay(ctx: Ctx) {
-    const statusDisplay = new StatusDisplay(ctx.config.cargoWatchOptions.command);
+    const statusDisplay = new StatusDisplay(ctx.config.checkOnSave.command);
    ctx.pushCleanup(statusDisplay);
    const client = ctx.client;
    if (client != null) {