Remove irrelevant distinction

crates/ra_ide/src/goto_definition.rs

@@ -78,7 +78,6 @@ pub(crate) fn reference_definition(
         Some(Macro(it)) => return Exact(it.to_nav(sb.db)),
         Some(Field(it)) => return Exact(it.to_nav(sb.db)),
         Some(TypeParam(it)) => return Exact(it.to_nav(sb.db)),
-        Some(AssocItem(it)) => return Exact(it.to_nav(sb.db)),
         Some(Local(it)) => return Exact(it.to_nav(sb.db)),
         Some(Def(def)) => match NavigationTarget::from_def(sb.db, def) {
             Some(nav) => return Exact(nav),

crates/ra_ide/src/hover.rs

@@ -105,11 +105,6 @@ fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<S
                 _ => None,
             }
         }
-        AssocItem(it) => match it {
-            hir::AssocItem::Function(it) => from_def_source(db, it),
-            hir::AssocItem::Const(it) => from_def_source(db, it),
-            hir::AssocItem::TypeAlias(it) => from_def_source(db, it),
-        },
         Def(it) => match it {
             hir::ModuleDef::Module(it) => match it.definition_source(db).value {
                 hir::ModuleSource::Module(it) => {

crates/ra_ide/src/references.rs

@@ -128,7 +128,6 @@ pub(crate) fn find_all_refs(
     let declaration = match def.kind {
         NameKind::Macro(mac) => mac.to_nav(db),
         NameKind::Field(field) => field.to_nav(db),
-        NameKind::AssocItem(assoc) => assoc.to_nav(db),
         NameKind::Def(def) => NavigationTarget::from_def(db, def)?,
         NameKind::SelfType(imp) => imp.to_nav(db),
         NameKind::Local(local) => local.to_nav(db),

crates/ra_ide/src/references/classify.rs

@@ -8,7 +8,7 @@ use test_utils::tested_by;
 use super::{NameDefinition, NameKind};
 use ra_ide_db::RootDatabase;
 
-pub use ra_ide_db::defs::{classify_name, from_assoc_item, from_module_def, from_struct_field};
+pub use ra_ide_db::defs::{classify_name, from_module_def, from_struct_field};
 
 pub(crate) fn classify_name_ref(
     sb: &mut SourceBinder<RootDatabase>,
@@ -22,7 +22,7 @@ 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_assoc_item(sb.db, func.into()));
+            return Some(from_module_def(sb.db, func.into(), None));
         }
     }
 
@@ -57,27 +57,35 @@ pub(crate) fn classify_name_ref(
 
     let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = analyzer.resolve_path(sb.db, &path)?;
-    match resolved {
-        PathResolution::Def(def) => Some(from_module_def(sb.db, def, Some(container))),
-        PathResolution::AssocItem(item) => Some(from_assoc_item(sb.db, item)),
+    let res = match resolved {
+        PathResolution::Def(def) => from_module_def(sb.db, def, Some(container)),
+        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);
-            Some(NameDefinition { kind, container, visibility: None })
+            NameDefinition { kind, container, visibility: None }
         }
         PathResolution::TypeParam(par) => {
             let kind = NameKind::TypeParam(par);
             let container = par.module(sb.db);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
         PathResolution::Macro(def) => {
             let kind = NameKind::Macro(def);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
         PathResolution::SelfType(impl_block) => {
             let kind = NameKind::SelfType(impl_block);
             let container = impl_block.module(sb.db);
-            Some(NameDefinition { kind, container, visibility })
+            NameDefinition { kind, container, visibility }
         }
-    }
+    };
+    Some(res)
 }

crates/ra_ide/src/syntax_highlighting.rs

@@ -321,9 +321,6 @@ fn highlight_name(db: &RootDatabase, name_kind: NameKind) -> &'static str {
     match name_kind {
         Macro(_) => tags::MACRO,
         Field(_) => tags::FIELD,
-        AssocItem(hir::AssocItem::Function(_)) => tags::FUNCTION,
-        AssocItem(hir::AssocItem::Const(_)) => tags::CONSTANT,
-        AssocItem(hir::AssocItem::TypeAlias(_)) => tags::TYPE,
         Def(hir::ModuleDef::Module(_)) => tags::MODULE,
         Def(hir::ModuleDef::Function(_)) => tags::FUNCTION,
         Def(hir::ModuleDef::Adt(_)) => tags::TYPE,