1 files changed, 23 insertions, 12 deletions

diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs
index 217f9951e..f12b58cb9 100644
--- a/crates/ra_ide_api/src/references/classify.rs
+++ b/crates/ra_ide_api/src/references/classify.rs
@@ -21,7 +21,6 @@ pub(crate) fn classify_name(
     let parent = name.syntax().parent()?;
     let file_id = file_id.into();
 
-    // FIXME: add ast::MacroCall(it)
     match_ast! {
         match parent {
             ast::BindPat(it) => {
@@ -104,6 +103,19 @@ pub(crate) fn classify_name(
                     Some(from_module_def(db, def.into(), None))
                 }
             },
+            ast::MacroCall(it) => {
+                let src = hir::Source { file_id, ast: it};
+                let def = hir::MacroDef::from_source(db, src.clone())?;
+
+                let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
+                let module = Module::from_definition(db, Source::new(file_id, module_src))?;
+
+                Some(NameDefinition {
+                    visibility: None,
+                    container: module,
+                    kind: NameKind::Macro(def),
+                })
+            },
             _ => None,
         }
     }
@@ -114,12 +126,11 @@ pub(crate) fn classify_name_ref(
     file_id: FileId,
     name_ref: &ast::NameRef,
 ) -> Option<NameDefinition> {
-    use PathResolution::*;
-
     let _p = profile("classify_name_ref");
 
     let parent = name_ref.syntax().parent()?;
-    let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+    let analyzer =
+        SourceAnalyzer::new(db, hir::Source::new(file_id.into(), name_ref.syntax()), None);
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_definition_works_for_methods);
@@ -146,8 +157,8 @@ pub(crate) fn classify_name_ref(
         }
     }
 
-    let ast = ModuleSource::from_child_node(db, file_id, &parent);
     let file_id = file_id.into();
+    let ast = ModuleSource::from_child_node(db, Source::new(file_id, &parent));
     // FIXME: find correct container and visibility for each case
     let container = Module::from_definition(db, Source { file_id, ast })?;
     let visibility = None;
@@ -163,26 +174,26 @@ pub(crate) fn classify_name_ref(
     let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = analyzer.resolve_path(db, &path)?;
     match resolved {
-        Def(def) => Some(from_module_def(db, def, Some(container))),
-        AssocItem(item) => Some(from_assoc_item(db, item)),
-        Local(local) => {
+        PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
+        PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)),
+        PathResolution::Local(local) => {
             let container = local.module(db);
             let kind = NameKind::Local(local);
             Some(NameDefinition { kind, container, visibility: None })
         }
-        GenericParam(par) => {
+        PathResolution::GenericParam(par) => {
             // FIXME: get generic param def
             let kind = NameKind::GenericParam(par);
             Some(NameDefinition { kind, container, visibility })
         }
-        Macro(def) => {
+        PathResolution::Macro(def) => {
             let kind = NameKind::Macro(def);
             Some(NameDefinition { kind, container, visibility })
         }
-        SelfType(impl_block) => {
+        PathResolution::SelfType(impl_block) => {
             let ty = impl_block.target_ty(db);
             let kind = NameKind::SelfType(ty);
-            let container = impl_block.module();
+            let container = impl_block.module(db);
             Some(NameDefinition { kind, container, visibility })
         }
     }