21 files changed, 333 insertions, 201 deletions

diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 4ab09b167..3f56dd508 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -549,6 +549,23 @@ fn main() {
 }
 
 #[test]
+fn doctest_remove_mut() {
+    check(
+        "remove_mut",
+        r#####"
+impl Walrus {
+    fn feed(&mut<|> self, amount: u32) {}
+}
+"#####,
+        r#####"
+impl Walrus {
+    fn feed(&self, amount: u32) {}
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_replace_if_let_with_match() {
     check(
         "replace_if_let_with_match",
diff --git a/crates/ra_assists/src/handlers/remove_mut.rs b/crates/ra_assists/src/handlers/remove_mut.rs
new file mode 100644
index 000000000..6884830eb
--- /dev/null
+++ b/crates/ra_assists/src/handlers/remove_mut.rs
@@ -0,0 +1,32 @@
+use ra_syntax::{SyntaxKind, TextRange, T};
+
+use crate::{Assist, AssistCtx, AssistId};
+
+// Assist: remove_mut
+//
+// Removes the `mut` keyword.
+//
+// ```
+// impl Walrus {
+//     fn feed(&mut<|> self, amount: u32) {}
+// }
+// ```
+// ->
+// ```
+// impl Walrus {
+//     fn feed(&self, amount: u32) {}
+// }
+// ```
+pub(crate) fn remove_mut(ctx: AssistCtx) -> Option<Assist> {
+    let mut_token = ctx.find_token_at_offset(T![mut])?;
+    let delete_from = mut_token.text_range().start();
+    let delete_to = match mut_token.next_token() {
+        Some(it) if it.kind() == SyntaxKind::WHITESPACE => it.text_range().end(),
+        _ => mut_token.text_range().end(),
+    };
+
+    ctx.add_assist(AssistId("remove_mut"), "Remove `mut` keyword", |edit| {
+        edit.set_cursor(delete_from);
+        edit.delete(TextRange::from_to(delete_from, delete_to));
+    })
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index a0e7fe17e..d7998b0d1 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -38,7 +38,7 @@ pub struct GroupLabel(pub String);
 impl AssistLabel {
     pub(crate) fn new(label: String, id: AssistId) -> AssistLabel {
         // FIXME: make fields private, so that this invariant can't be broken
-        assert!(label.chars().next().unwrap().is_uppercase());
+        assert!(label.starts_with(|c: char| c.is_uppercase()));
         AssistLabel { label, id }
     }
 }
@@ -108,6 +108,7 @@ mod handlers {
     mod introduce_variable;
     mod inline_local_variable;
     mod raw_string;
+    mod remove_mut;
     mod replace_if_let_with_match;
     mod split_import;
     mod remove_dbg;
@@ -147,6 +148,7 @@ mod handlers {
             raw_string::make_raw_string,
             raw_string::make_usual_string,
             raw_string::remove_hash,
+            remove_mut::remove_mut,
             early_return::convert_to_guarded_return,
             auto_import::auto_import,
         ]
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 1bdcda069..efc3502d0 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -30,6 +30,7 @@ use ra_syntax::{
     ast::{self, AttrsOwner},
     AstNode,
 };
+use rustc_hash::FxHashSet;
 
 use crate::{
     db::{DefDatabase, HirDatabase},
@@ -123,10 +124,25 @@ impl_froms!(
     BuiltinType
 );
 
+impl ModuleDef {
+    pub fn module(self, db: &impl HirDatabase) -> Option<Module> {
+        match self {
+            ModuleDef::Module(it) => it.parent(db),
+            ModuleDef::Function(it) => Some(it.module(db)),
+            ModuleDef::Adt(it) => Some(it.module(db)),
+            ModuleDef::EnumVariant(it) => Some(it.module(db)),
+            ModuleDef::Const(it) => Some(it.module(db)),
+            ModuleDef::Static(it) => Some(it.module(db)),
+            ModuleDef::Trait(it) => Some(it.module(db)),
+            ModuleDef::TypeAlias(it) => Some(it.module(db)),
+            ModuleDef::BuiltinType(_) => None,
+        }
+    }
+}
+
 pub use hir_def::{
     attr::Attrs, item_scope::ItemInNs, visibility::Visibility, AssocItemId, AssocItemLoc,
 };
-use rustc_hash::FxHashSet;
 
 impl Module {
     pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
@@ -649,6 +665,17 @@ pub struct MacroDef {
     pub(crate) id: MacroDefId,
 }
 
+impl MacroDef {
+    /// FIXME: right now, this just returns the root module of the crate that
+    /// defines this macro. The reasons for this is that macros are expanded
+    /// early, in `ra_hir_expand`, where modules simply do not exist yet.
+    pub fn module(self, db: &impl HirDatabase) -> Option<Module> {
+        let krate = self.id.krate?;
+        let module_id = db.crate_def_map(krate).root;
+        Some(Module::new(Crate { id: krate }, module_id))
+    }
+}
+
 /// Invariant: `inner.as_assoc_item(db).is_some()`
 /// We do not actively enforce this invariant.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
index 0d11b537c..22f24890d 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/expr.rs
@@ -15,6 +15,7 @@ use rustc_hash::FxHashSet;
 use crate::{
     db::HirDatabase,
     diagnostics::{MissingFields, MissingOkInTailExpr},
+    utils::variant_data,
     ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
 
@@ -27,6 +28,7 @@ pub use hir_def::{
         ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
         MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
     },
+    VariantId,
 };
 
 pub struct ExprValidator<'a, 'b: 'a> {
@@ -69,17 +71,19 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
     ) {
         if spread.is_some() {
             return;
+        };
+        let variant_def: VariantId = match self.infer.variant_resolution_for_expr(id) {
+            Some(VariantId::UnionId(_)) | None => return,
+            Some(it) => it,
+        };
+        if let VariantId::UnionId(_) = variant_def {
+            return;
         }
 
-        let struct_def = match self.infer[id].as_adt() {
-            Some((AdtId::StructId(s), _)) => s,
-            _ => return,
-        };
-        let struct_data = db.struct_data(struct_def);
+        let variant_data = variant_data(db, variant_def);
 
         let lit_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
-        let missed_fields: Vec<Name> = struct_data
-            .variant_data
+        let missed_fields: Vec<Name> = variant_data
             .fields()
             .iter()
             .filter_map(|(_f, d)| {
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 1a3bcffae..a524987fd 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -135,11 +135,7 @@ impl Completions {
             let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
             // Ensure to match the full word
             if after.starts_with('!')
-                && before
-                    .chars()
-                    .rev()
-                    .next()
-                    .map_or(true, |c| c != '_' && !c.is_ascii_alphanumeric())
+                && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric())
             {
                 // It may have spaces before the braces like `foo! {}`
                 match after[1..].chars().find(|&c| !c.is_whitespace()) {
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 82596c665..9cf86b26d 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -470,6 +470,35 @@ mod tests {
     }
 
     #[test]
+    fn test_fill_struct_fields_enum() {
+        let before = r"
+            enum Expr {
+                Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+            }
+
+            impl Expr {
+                fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+                    Expr::Bin { <|> }
+                }
+            }
+
+        ";
+        let after = r"
+            enum Expr {
+                Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+            }
+
+            impl Expr {
+                fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+                    Expr::Bin { lhs: (), rhs: () <|> }
+                }
+            }
+
+        ";
+        check_apply_diagnostic_fix(before, after);
+    }
+
+    #[test]
     fn test_fill_struct_fields_partial() {
         let before = r"
             struct TestStruct {
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index 726963a33..4757d8e22 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -44,6 +44,7 @@ fn try_extend_selection(
         ARRAY_EXPR,
         TUPLE_EXPR,
         TUPLE_TYPE,
+        TUPLE_PAT,
         WHERE_CLAUSE,
     ];
 
@@ -612,6 +613,32 @@ fn main() { let var = (
     }
 
     #[test]
+    fn test_extend_selection_on_tuple_pat() {
+        do_check(
+            r#"fn main() { let (krate, _crate_def_map<|>, module_id) = var; }"#,
+            &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
+        );
+        // white space variations
+        do_check(
+            r#"fn main() { let (krate,_crate<|>_def_map,module_id) = var; }"#,
+            &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
+        );
+        do_check(
+            r#"
+fn main() { let (
+    krate,
+    _crate_def_map<|>,
+    module_id
+) = var; }"#,
+            &[
+                "_crate_def_map",
+                "_crate_def_map,",
+                "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
+            ],
+        );
+    }
+
+    #[test]
     fn extend_selection_inside_macros() {
         do_check(
             r#"macro_rules! foo { ($item:item) => {$item} }
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index de5551a4c..cce539e56 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use hir::{db::AstDatabase, InFile, SourceBinder};
-use ra_ide_db::{symbol_index, RootDatabase};
+use ra_ide_db::{defs::NameDefinition, symbol_index, RootDatabase};
 use ra_syntax::{
     ast::{self, DocCommentsOwner},
     match_ast, AstNode,
@@ -12,7 +12,7 @@ use ra_syntax::{
 use crate::{
     display::{ShortLabel, ToNav},
     expand::descend_into_macros,
-    references::{classify_name_ref, NameKind::*},
+    references::classify_name_ref,
     FilePosition, NavigationTarget, RangeInfo,
 };
 
@@ -73,17 +73,17 @@ pub(crate) fn reference_definition(
 ) -> ReferenceResult {
     use self::ReferenceResult::*;
 
-    let name_kind = classify_name_ref(sb, name_ref).map(|d| d.kind);
+    let name_kind = classify_name_ref(sb, name_ref);
     match name_kind {
-        Some(Macro(it)) => return Exact(it.to_nav(sb.db)),
-        Some(StructField(it)) => return Exact(it.to_nav(sb.db)),
-        Some(TypeParam(it)) => return Exact(it.to_nav(sb.db)),
-        Some(Local(it)) => return Exact(it.to_nav(sb.db)),
-        Some(ModuleDef(def)) => match NavigationTarget::from_def(sb.db, def) {
+        Some(NameDefinition::Macro(it)) => return Exact(it.to_nav(sb.db)),
+        Some(NameDefinition::StructField(it)) => return Exact(it.to_nav(sb.db)),
+        Some(NameDefinition::TypeParam(it)) => return Exact(it.to_nav(sb.db)),
+        Some(NameDefinition::Local(it)) => return Exact(it.to_nav(sb.db)),
+        Some(NameDefinition::ModuleDef(def)) => match NavigationTarget::from_def(sb.db, def) {
             Some(nav) => return Exact(nav),
             None => return Approximate(vec![]),
         },
-        Some(SelfType(imp)) => {
+        Some(NameDefinition::SelfType(imp)) => {
             // FIXME: ideally, this should point to the type in the impl, and
             // not at the whole impl. And goto **type** definition should bring
             // us to the actual type
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 3f88bb260..1c6ca36df 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -2,7 +2,7 @@
 
 use hir::{db::AstDatabase, Adt, HasSource, HirDisplay, SourceBinder};
 use ra_db::SourceDatabase;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{defs::NameDefinition, RootDatabase};
 use ra_syntax::{
     algo::find_covering_element,
     ast::{self, DocCommentsOwner},
@@ -13,8 +13,8 @@ use ra_syntax::{
 
 use crate::{
     display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
-    expand::descend_into_macros,
-    references::{classify_name, classify_name_ref, NameKind, NameKind::*},
+    expand::{descend_into_macros, original_range},
+    references::{classify_name, classify_name_ref},
     FilePosition, FileRange, RangeInfo,
 };
 
@@ -92,20 +92,20 @@ fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
     }
 }
 
-fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<String> {
-    return match name_kind {
-        Macro(it) => {
+fn hover_text_from_name_kind(db: &RootDatabase, def: NameDefinition) -> Option<String> {
+    return match def {
+        NameDefinition::Macro(it) => {
             let src = it.source(db);
             hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)))
         }
-        StructField(it) => {
+        NameDefinition::StructField(it) => {
             let src = it.source(db);
             match src.value {
                 hir::FieldSource::Named(it) => hover_text(it.doc_comment_text(), it.short_label()),
                 _ => None,
             }
         }
-        ModuleDef(it) => match it {
+        NameDefinition::ModuleDef(it) => match it {
             hir::ModuleDef::Module(it) => match it.definition_source(db).value {
                 hir::ModuleSource::Module(it) => {
                     hover_text(it.doc_comment_text(), it.short_label())
@@ -123,8 +123,10 @@ fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<S
             hir::ModuleDef::TypeAlias(it) => from_def_source(db, it),
             hir::ModuleDef::BuiltinType(it) => Some(it.to_string()),
         },
-        Local(it) => Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string())),
-        TypeParam(_) | SelfType(_) => {
+        NameDefinition::Local(it) => {
+            Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string()))
+        }
+        NameDefinition::TypeParam(_) | NameDefinition::SelfType(_) => {
             // FIXME: Hover for generic param
             None
         }
@@ -148,17 +150,18 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
     let mut res = HoverResult::new();
 
     let mut sb = SourceBinder::new(db);
-    if let Some((range, name_kind)) = match_ast! {
+    if let Some((node, name_kind)) = match_ast! {
         match (token.value.parent()) {
             ast::NameRef(name_ref) => {
-                classify_name_ref(&mut sb, token.with_value(&name_ref)).map(|d| (name_ref.syntax().text_range(), d.kind))
+                classify_name_ref(&mut sb, token.with_value(&name_ref)).map(|d| (name_ref.syntax().clone(), d))
             },
             ast::Name(name) => {
-                classify_name(&mut sb, token.with_value(&name)).map(|d| (name.syntax().text_range(), d.kind))
+                classify_name(&mut sb, token.with_value(&name)).map(|d| (name.syntax().clone(), d))
             },
             _ => None,
         }
     } {
+        let range = original_range(db, token.with_value(&node)).range;
         res.extend(hover_text_from_name_kind(db, name_kind));
 
         if !res.is_empty() {
@@ -171,8 +174,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
         .ancestors()
         .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
 
-    // The following logic will not work if token is coming from a macro
-    let frange = FileRange { file_id: position.file_id, range: node.text_range() };
+    let frange = original_range(db, token.with_value(&node));
     res.extend(type_of(db, frange).map(rust_code_markup));
     if res.is_empty() {
         return None;
@@ -220,6 +222,7 @@ mod tests {
     use crate::mock_analysis::{
         analysis_and_position, single_file_with_position, single_file_with_range,
     };
+    use ra_db::FileLoader;
     use ra_syntax::TextRange;
 
     fn trim_markup(s: &str) -> &str {
@@ -230,7 +233,7 @@ mod tests {
         s.map(trim_markup)
     }
 
-    fn check_hover_result(fixture: &str, expected: &[&str]) {
+    fn check_hover_result(fixture: &str, expected: &[&str]) -> String {
         let (analysis, position) = analysis_and_position(fixture);
         let hover = analysis.hover(position).unwrap().unwrap();
         let mut results = Vec::from(hover.info.results());
@@ -243,6 +246,9 @@ mod tests {
         }
 
         assert_eq!(hover.info.len(), expected.len());
+
+        let content = analysis.db.file_text(position.file_id);
+        content[hover.range].to_string()
     }
 
     #[test]
@@ -711,7 +717,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
 
     #[test]
     fn test_hover_through_macro() {
-        check_hover_result(
+        let hover_on = check_hover_result(
             "
             //- /lib.rs
             macro_rules! id {
@@ -726,11 +732,13 @@ fn func(foo: i32) { if true { <|>foo; }; }
             ",
             &["fn foo()"],
         );
+
+        assert_eq!(hover_on, "foo")
     }
 
     #[test]
     fn test_hover_through_expr_in_macro() {
-        check_hover_result(
+        let hover_on = check_hover_result(
             "
             //- /lib.rs
             macro_rules! id {
@@ -742,5 +750,24 @@ fn func(foo: i32) { if true { <|>foo; }; }
             ",
             &["u32"],
         );
+
+        assert_eq!(hover_on, "bar")
+    }
+
+    #[test]
+    fn test_hover_non_ascii_space_doc() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            ///　<- `\u{3000}` here
+            fn foo() {
+            }
+
+            fn bar() {
+                fo<|>o();
+            }
+            ",
+            &["fn foo()\n```\n\n<- `\u{3000}` here"],
+        );
     }
 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 97c08ade5..7f790a62d 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -31,7 +31,7 @@ pub(crate) use self::{
     classify::{classify_name, classify_name_ref},
     rename::rename,
 };
-pub(crate) use ra_ide_db::defs::{NameDefinition, NameKind};
+pub(crate) use ra_ide_db::defs::NameDefinition;
 
 pub use self::search_scope::SearchScope;
 
@@ -126,13 +126,13 @@ pub(crate) fn find_all_refs(
 
     let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position, opt_name)?;
 
-    let declaration = match def.kind {
-        NameKind::Macro(mac) => mac.to_nav(db),
-        NameKind::StructField(field) => field.to_nav(db),
-        NameKind::ModuleDef(def) => NavigationTarget::from_def(db, def)?,
-        NameKind::SelfType(imp) => imp.to_nav(db),
-        NameKind::Local(local) => local.to_nav(db),
-        NameKind::TypeParam(_) => return None,
+    let declaration = match def {
+        NameDefinition::Macro(mac) => mac.to_nav(db),
+        NameDefinition::StructField(field) => field.to_nav(db),
+        NameDefinition::ModuleDef(def) => NavigationTarget::from_def(db, def)?,
+        NameDefinition::SelfType(imp) => imp.to_nav(db),
+        NameDefinition::Local(local) => local.to_nav(db),
+        NameDefinition::TypeParam(_) => return None,
     };
 
     let search_scope = {
@@ -148,7 +148,7 @@ pub(crate) fn find_all_refs(
     let declaration = Declaration {
         nav: declaration,
         kind: ReferenceKind::Other,
-        access: decl_access(&def.kind, &name, &syntax, decl_range),
+        access: decl_access(&def, &name, &syntax, decl_range),
     };
 
     let references = process_definition(db, def, name, search_scope)
@@ -247,7 +247,7 @@ fn process_definition(
                     refs.push(Reference {
                         file_range: FileRange { file_id, range },
                         kind,
-                        access: reference_access(&d.kind, &name_ref.value),
+                        access: reference_access(&d, &name_ref.value),
                     });
                 }
             }
@@ -257,13 +257,13 @@ fn process_definition(
 }
 
 fn decl_access(
-    kind: &NameKind,
+    def: &NameDefinition,
     name: &str,
     syntax: &SyntaxNode,
     range: TextRange,
 ) -> Option<ReferenceAccess> {
-    match kind {
-        NameKind::Local(_) | NameKind::StructField(_) => {}
+    match def {
+        NameDefinition::Local(_) | NameDefinition::StructField(_) => {}
         _ => return None,
     };
 
@@ -280,10 +280,10 @@ fn decl_access(
     None
 }
 
-fn reference_access(kind: &NameKind, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
+fn reference_access(def: &NameDefinition, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
     // Only Locals and Fields have accesses for now.
-    match kind {
-        NameKind::Local(_) | NameKind::StructField(_) => {}
+    match def {
+        NameDefinition::Local(_) | NameDefinition::StructField(_) => {}
         _ => return None,
     };
 
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index d0f03d8a8..478e18871 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -5,7 +5,7 @@ use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
 
-use super::{NameDefinition, NameKind};
+use super::NameDefinition;
 use ra_ide_db::RootDatabase;
 
 pub use ra_ide_db::defs::{classify_name, from_module_def, from_struct_field};
@@ -22,14 +22,14 @@ pub(crate) fn classify_name_ref(
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
         if let Some(func) = analyzer.resolve_method_call(&method_call) {
-            return Some(from_module_def(sb.db, func.into(), None));
+            return Some(from_module_def(func.into()));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_fields);
         if let Some(field) = analyzer.resolve_field(&field_expr) {
-            return Some(from_struct_field(sb.db, field));
+            return Some(from_struct_field(field));
         }
     }
 
@@ -37,55 +37,35 @@ pub(crate) fn classify_name_ref(
         tested_by!(goto_def_for_record_fields);
         tested_by!(goto_def_for_field_init_shorthand);
         if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
-            return Some(from_struct_field(sb.db, field_def));
+            return Some(from_struct_field(field_def));
         }
     }
 
-    // FIXME: find correct container and visibility for each case
-    let visibility = None;
-    let container = sb.to_module_def(name_ref.file_id.original_file(sb.db))?;
-
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
         tested_by!(goto_def_for_macros);
         if let Some(macro_def) =
             analyzer.resolve_macro_call(sb.db, name_ref.with_value(&macro_call))
         {
-            let kind = NameKind::Macro(macro_def);
-            return Some(NameDefinition { kind, container, visibility });
+            return Some(NameDefinition::Macro(macro_def));
         }
     }
 
     let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = analyzer.resolve_path(sb.db, &path)?;
     let res = match resolved {
-        PathResolution::Def(def) => from_module_def(sb.db, def, Some(container)),
+        PathResolution::Def(def) => from_module_def(def),
         PathResolution::AssocItem(item) => {
             let def = match item {
                 hir::AssocItem::Function(it) => it.into(),
                 hir::AssocItem::Const(it) => it.into(),
                 hir::AssocItem::TypeAlias(it) => it.into(),
             };
-            from_module_def(sb.db, def, Some(container))
-        }
-        PathResolution::Local(local) => {
-            let kind = NameKind::Local(local);
-            let container = local.module(sb.db);
-            NameDefinition { kind, container, visibility: None }
-        }
-        PathResolution::TypeParam(par) => {
-            let kind = NameKind::TypeParam(par);
-            let container = par.module(sb.db);
-            NameDefinition { kind, container, visibility }
-        }
-        PathResolution::Macro(def) => {
-            let kind = NameKind::Macro(def);
-            NameDefinition { kind, container, visibility }
-        }
-        PathResolution::SelfType(impl_block) => {
-            let kind = NameKind::SelfType(impl_block);
-            let container = impl_block.module(sb.db);
-            NameDefinition { kind, container, visibility }
+            from_module_def(def)
         }
+        PathResolution::Local(local) => NameDefinition::Local(local),
+        PathResolution::TypeParam(par) => NameDefinition::TypeParam(par),
+        PathResolution::Macro(def) => NameDefinition::Macro(def),
+        PathResolution::SelfType(impl_block) => NameDefinition::SelfType(impl_block),
     };
     Some(res)
 }
diff --git a/crates/ra_ide/src/references/search_scope.rs b/crates/ra_ide/src/references/search_scope.rs
index 279f57be0..27d483233 100644
--- a/crates/ra_ide/src/references/search_scope.rs
+++ b/crates/ra_ide/src/references/search_scope.rs
@@ -12,20 +12,27 @@ use rustc_hash::FxHashMap;
 
 use ra_ide_db::RootDatabase;
 
-use super::{NameDefinition, NameKind};
+use super::NameDefinition;
 
 pub struct SearchScope {
     entries: FxHashMap<FileId, Option<TextRange>>,
 }
 
 impl SearchScope {
+    fn empty() -> SearchScope {
+        SearchScope { entries: FxHashMap::default() }
+    }
+
     pub(crate) fn for_def(def: &NameDefinition, db: &RootDatabase) -> SearchScope {
         let _p = profile("search_scope");
-
-        let module_src = def.container.definition_source(db);
+        let module = match def.module(db) {
+            Some(it) => it,
+            None => return SearchScope::empty(),
+        };
+        let module_src = module.definition_source(db);
         let file_id = module_src.file_id.original_file(db);
 
-        if let NameKind::Local(var) = def.kind {
+        if let NameDefinition::Local(var) = def {
             let range = match var.parent(db) {
                 DefWithBody::Function(f) => f.source(db).value.syntax().text_range(),
                 DefWithBody::Const(c) => c.source(db).value.syntax().text_range(),
@@ -36,10 +43,10 @@ impl SearchScope {
             return SearchScope::new(res);
         }
 
-        let vis = def.visibility.as_ref().map(|v| v.syntax().to_string()).unwrap_or_default();
+        let vis = def.visibility(db).as_ref().map(|v| v.syntax().to_string()).unwrap_or_default();
 
         if vis.as_str() == "pub(super)" {
-            if let Some(parent_module) = def.container.parent(db) {
+            if let Some(parent_module) = module.parent(db) {
                 let mut res = FxHashMap::default();
                 let parent_src = parent_module.definition_source(db);
                 let file_id = parent_src.file_id.original_file(db);
@@ -72,7 +79,7 @@ impl SearchScope {
                 return SearchScope::new(res);
             }
             if vis.as_str() == "pub" {
-                let krate = def.container.krate();
+                let krate = module.krate();
                 for rev_dep in krate.reverse_dependencies(db) {
                     let root_file = rev_dep.root_file(db);
                     let source_root_id = db.file_source_root(root_file);
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 8e793e479..d873f153e 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -2,7 +2,7 @@
 
 use hir::{HirFileId, InFile, Name, SourceAnalyzer, SourceBinder};
 use ra_db::SourceDatabase;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{defs::NameDefinition, RootDatabase};
 use ra_prof::profile;
 use ra_syntax::{
     ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken, TextRange,
@@ -12,7 +12,7 @@ use rustc_hash::FxHashMap;
 
 use crate::{
     expand::descend_into_macros_with_analyzer,
-    references::{classify_name, classify_name_ref, NameKind},
+    references::{classify_name, classify_name_ref},
     FileId,
 };
 
@@ -186,10 +186,10 @@ fn highlight_node(
         NAME_REF if node.value.ancestors().any(|it| it.kind() == ATTR) => return None,
         NAME_REF => {
             let name_ref = node.value.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-            let name_kind = classify_name_ref(sb, node.with_value(&name_ref)).map(|d| d.kind);
+            let name_kind = classify_name_ref(sb, node.with_value(&name_ref));
             match name_kind {
                 Some(name_kind) => {
-                    if let NameKind::Local(local) = &name_kind {
+                    if let NameDefinition::Local(local) = &name_kind {
                         if let Some(name) = local.name(db) {
                             let shadow_count =
                                 bindings_shadow_count.entry(name.clone()).or_default();
@@ -205,9 +205,9 @@ fn highlight_node(
         }
         NAME => {
             let name = node.value.as_node().cloned().and_then(ast::Name::cast).unwrap();
-            let name_kind = classify_name(sb, node.with_value(&name)).map(|d| d.kind);
+            let name_kind = classify_name(sb, node.with_value(&name));
 
-            if let Some(NameKind::Local(local)) = &name_kind {
+            if let Some(NameDefinition::Local(local)) = &name_kind {
                 if let Some(name) = local.name(db) {
                     let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
                     *shadow_count += 1;
@@ -310,22 +310,22 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
     buf
 }
 
-fn highlight_name(db: &RootDatabase, name_kind: NameKind) -> &'static str {
-    match name_kind {
-        NameKind::Macro(_) => tags::MACRO,
-        NameKind::StructField(_) => tags::FIELD,
-        NameKind::ModuleDef(hir::ModuleDef::Module(_)) => tags::MODULE,
-        NameKind::ModuleDef(hir::ModuleDef::Function(_)) => tags::FUNCTION,
-        NameKind::ModuleDef(hir::ModuleDef::Adt(_)) => tags::TYPE,
-        NameKind::ModuleDef(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
-        NameKind::ModuleDef(hir::ModuleDef::Const(_)) => tags::CONSTANT,
-        NameKind::ModuleDef(hir::ModuleDef::Static(_)) => tags::CONSTANT,
-        NameKind::ModuleDef(hir::ModuleDef::Trait(_)) => tags::TYPE,
-        NameKind::ModuleDef(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
-        NameKind::ModuleDef(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
-        NameKind::SelfType(_) => tags::TYPE_SELF,
-        NameKind::TypeParam(_) => tags::TYPE_PARAM,
-        NameKind::Local(local) => {
+fn highlight_name(db: &RootDatabase, def: NameDefinition) -> &'static str {
+    match def {
+        NameDefinition::Macro(_) => tags::MACRO,
+        NameDefinition::StructField(_) => tags::FIELD,
+        NameDefinition::ModuleDef(hir::ModuleDef::Module(_)) => tags::MODULE,
+        NameDefinition::ModuleDef(hir::ModuleDef::Function(_)) => tags::FUNCTION,
+        NameDefinition::ModuleDef(hir::ModuleDef::Adt(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::Const(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::Static(_)) => tags::CONSTANT,
+        NameDefinition::ModuleDef(hir::ModuleDef::Trait(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
+        NameDefinition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
+        NameDefinition::SelfType(_) => tags::TYPE_SELF,
+        NameDefinition::TypeParam(_) => tags::TYPE_PARAM,
+        NameDefinition::Local(local) => {
             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
                 tags::VARIABLE_MUT
             } else {
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 030f44f86..04c214624 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    Adt, HasSource, ImplBlock, InFile, Local, MacroDef, Module, ModuleDef, SourceBinder,
-    StructField, TypeParam, VariantDef,
+    Adt, FieldSource, HasSource, ImplBlock, InFile, Local, MacroDef, Module, ModuleDef,
+    SourceBinder, StructField, TypeParam,
 };
 use ra_prof::profile;
 use ra_syntax::{
@@ -18,7 +18,7 @@ use ra_syntax::{
 use crate::RootDatabase;
 
 #[derive(Debug, PartialEq, Eq)]
-pub enum NameKind {
+pub enum NameDefinition {
     Macro(MacroDef),
     StructField(StructField),
     ModuleDef(ModuleDef),
@@ -27,13 +27,45 @@ pub enum NameKind {
     TypeParam(TypeParam),
 }
 
-#[derive(PartialEq, Eq)]
-pub struct NameDefinition {
-    pub visibility: Option<ast::Visibility>,
-    /// FIXME: this doesn't really make sense. For example, builtin types don't
-    /// really have a module.
-    pub container: Module,
-    pub kind: NameKind,
+impl NameDefinition {
+    pub fn module(&self, db: &RootDatabase) -> Option<Module> {
+        match self {
+            NameDefinition::Macro(it) => it.module(db),
+            NameDefinition::StructField(it) => Some(it.parent_def(db).module(db)),
+            NameDefinition::ModuleDef(it) => it.module(db),
+            NameDefinition::SelfType(it) => Some(it.module(db)),
+            NameDefinition::Local(it) => Some(it.module(db)),
+            NameDefinition::TypeParam(it) => Some(it.module(db)),
+        }
+    }
+
+    pub fn visibility(&self, db: &RootDatabase) -> Option<ast::Visibility> {
+        match self {
+            NameDefinition::Macro(_) => None,
+            NameDefinition::StructField(sf) => match sf.source(db).value {
+                FieldSource::Named(it) => it.visibility(),
+                FieldSource::Pos(it) => it.visibility(),
+            },
+            NameDefinition::ModuleDef(def) => match def {
+                ModuleDef::Module(it) => it.declaration_source(db)?.value.visibility(),
+                ModuleDef::Function(it) => it.source(db).value.visibility(),
+                ModuleDef::Adt(adt) => match adt {
+                    Adt::Struct(it) => it.source(db).value.visibility(),
+                    Adt::Union(it) => it.source(db).value.visibility(),
+                    Adt::Enum(it) => it.source(db).value.visibility(),
+                },
+                ModuleDef::Const(it) => it.source(db).value.visibility(),
+                ModuleDef::Static(it) => it.source(db).value.visibility(),
+                ModuleDef::Trait(it) => it.source(db).value.visibility(),
+                ModuleDef::TypeAlias(it) => it.source(db).value.visibility(),
+                ModuleDef::EnumVariant(_) => None,
+                ModuleDef::BuiltinType(_) => None,
+            },
+            NameDefinition::SelfType(_) => None,
+            NameDefinition::Local(_) => None,
+            NameDefinition::TypeParam(_) => None,
+        }
+    }
 }
 
 pub fn classify_name(
@@ -48,125 +80,77 @@ pub fn classify_name(
             ast::BindPat(it) => {
                 let src = name.with_value(it);
                 let local = sb.to_def(src)?;
-                Some(NameDefinition {
-                    visibility: None,
-                    container: local.module(sb.db),
-                    kind: NameKind::Local(local),
-                })
+                Some(NameDefinition::Local(local))
             },
             ast::RecordFieldDef(it) => {
                 let src = name.with_value(it);
                 let field: hir::StructField = sb.to_def(src)?;
-                Some(from_struct_field(sb.db, field))
+                Some(from_struct_field(field))
             },
             ast::Module(it) => {
                 let def = sb.to_def(name.with_value(it))?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::StructDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Struct = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::EnumDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Enum = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::TraitDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Trait = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::StaticDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Static = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::EnumVariant(it) => {
                 let src = name.with_value(it);
                 let def: hir::EnumVariant = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::FnDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Function = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::ConstDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::Const = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::TypeAliasDef(it) => {
                 let src = name.with_value(it);
                 let def: hir::TypeAlias = sb.to_def(src)?;
-                Some(from_module_def(sb.db, def.into(), None))
+                Some(from_module_def(def.into()))
             },
             ast::MacroCall(it) => {
                 let src = name.with_value(it);
                 let def = sb.to_def(src.clone())?;
 
-                let module = sb.to_module_def(src.file_id.original_file(sb.db))?;
-
-                Some(NameDefinition {
-                    visibility: None,
-                    container: module,
-                    kind: NameKind::Macro(def),
-                })
+                Some(NameDefinition::Macro(def))
             },
             ast::TypeParam(it) => {
                 let src = name.with_value(it);
                 let def = sb.to_def(src)?;
-                Some(NameDefinition {
-                    visibility: None,
-                    container: def.module(sb.db),
-                    kind: NameKind::TypeParam(def),
-                })
+                Some(NameDefinition::TypeParam(def))
             },
             _ => None,
         }
     }
 }
 
-pub fn from_struct_field(db: &RootDatabase, field: StructField) -> NameDefinition {
-    let kind = NameKind::StructField(field);
-    let parent = field.parent_def(db);
-    let container = parent.module(db);
-    let visibility = match parent {
-        VariantDef::Struct(s) => s.source(db).value.visibility(),
-        VariantDef::Union(e) => e.source(db).value.visibility(),
-        VariantDef::EnumVariant(e) => e.source(db).value.parent_enum().visibility(),
-    };
-    NameDefinition { kind, container, visibility }
+pub fn from_struct_field(field: StructField) -> NameDefinition {
+    NameDefinition::StructField(field)
 }
 
-pub fn from_module_def(
-    db: &RootDatabase,
-    def: ModuleDef,
-    module: Option<Module>,
-) -> NameDefinition {
-    let kind = NameKind::ModuleDef(def);
-    let (container, visibility) = match def {
-        ModuleDef::Module(it) => {
-            let container = it.parent(db).or_else(|| Some(it)).unwrap();
-            let visibility = it.declaration_source(db).and_then(|s| s.value.visibility());
-            (container, visibility)
-        }
-        ModuleDef::EnumVariant(it) => {
-            let container = it.module(db);
-            let visibility = it.source(db).value.parent_enum().visibility();
-            (container, visibility)
-        }
-        ModuleDef::Function(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Const(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Static(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Trait(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).value.visibility()),
-        ModuleDef::BuiltinType(..) => (module.unwrap(), None),
-    };
-    NameDefinition { kind, container, visibility }
+pub fn from_module_def(def: ModuleDef) -> NameDefinition {
+    NameDefinition::ModuleDef(def)
 }
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index 86383bcd0..b8dd358a9 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -6,8 +6,7 @@ use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
 
 use crate::{
-    defs::classify_name,
-    defs::NameKind,
+    defs::{classify_name, NameDefinition},
     symbol_index::{self, FileSymbol, Query},
     RootDatabase,
 };
@@ -44,7 +43,7 @@ impl<'a> ImportsLocator<'a> {
             .chain(lib_results.into_iter())
             .filter_map(|import_candidate| self.get_name_definition(db, &import_candidate))
             .filter_map(|name_definition_to_import| match name_definition_to_import {
-                NameKind::ModuleDef(module_def) => Some(module_def),
+                NameDefinition::ModuleDef(module_def) => Some(module_def),
                 _ => None,
             })
             .collect()
@@ -54,7 +53,7 @@ impl<'a> ImportsLocator<'a> {
         &mut self,
         db: &impl HirDatabase,
         import_candidate: &FileSymbol,
-    ) -> Option<NameKind> {
+    ) -> Option<NameDefinition> {
         let _p = profile("get_name_definition");
         let file_id = import_candidate.file_id.into();
         let candidate_node = import_candidate.ptr.to_node(&db.parse_or_expand(file_id)?);
@@ -67,6 +66,5 @@ impl<'a> ImportsLocator<'a> {
             &mut self.source_binder,
             hir::InFile { file_id, value: &ast::Name::cast(candidate_name_node)? },
         )
-        .map(|it| it.kind)
     }
 }
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index eb8b79e9a..dacca8279 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -141,7 +141,7 @@ fn convert_literal(l: &tt::Literal) -> TtToken {
 }
 
 fn convert_ident(ident: &tt::Ident) -> TtToken {
-    let kind = if let Some('\'') = ident.text.chars().next() {
+    let kind = if ident.text.starts_with('\'') {
         LIFETIME
     } else {
         SyntaxKind::from_keyword(ident.text.as_str()).unwrap_or(IDENT)
diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml
index e06a6d7d2..823745795 100644
--- a/crates/ra_prof/Cargo.toml
+++ b/crates/ra_prof/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 [dependencies]
 once_cell = "1.3.1"
 itertools = "0.8.2"
-backtrace = "0.3.44"
+backtrace = { version = "0.3.44", optional = true }
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 jemallocator = { version = "0.3.2", optional = true }
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 660d85b42..6853a4794 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -315,6 +315,7 @@ fn idx_to_children(msgs: &[Message]) -> Vec<Vec<usize>> {
 }
 
 /// Prints backtrace to stderr, useful for debugging.
+#[cfg(feature = "backtrace")]
 pub fn print_backtrace() {
     let bt = backtrace::Backtrace::new();
     eprintln!("{:?}", bt);
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
index f99984fe0..f8cf1e3eb 100644
--- a/crates/ra_syntax/src/ast/traits.rs
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -126,8 +126,8 @@ pub trait DocCommentsOwner: AstNode {
 
                 // Determine if the prefix or prefix + 1 char is stripped
                 let pos =
-                    if line.chars().nth(prefix_len).map(|c| c.is_whitespace()).unwrap_or(false) {
-                        prefix_len + 1
+                    if let Some(ws) = line.chars().nth(prefix_len).filter(|c| c.is_whitespace()) {
+                        prefix_len + ws.len_utf8()
                     } else {
                         prefix_len
                     };
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index c4711076c..c9fd645f1 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -57,6 +57,7 @@ pub fn server_capabilities() -> ServerCapabilities {
         execute_command_provider: None,
         workspace: None,
         call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
+        semantic_tokens_provider: None,
         experimental: Default::default(),
     }
 }