1 files changed, 75 insertions, 36 deletions

diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 01f51ba5d..66cb4b357 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -12,7 +12,7 @@ use hir_expand::name::AsName;
 use ra_db::FileId;
 use ra_syntax::{
     ast::{self, AstNode},
-    AstPtr,
+    match_ast, AstPtr,
     SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
 };
@@ -27,9 +27,9 @@ use crate::{
     },
     ids::LocationCtx,
     resolve::{ScopeDef, TypeNs, ValueNs},
-    ty::method_resolution::implements_trait,
-    Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId, MacroDef, Module,
-    Name, Path, Resolver, Static, Struct, Ty,
+    ty::method_resolution::{self, implements_trait},
+    AssocItem, Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId,
+    MacroDef, Module, Name, Path, Resolver, Static, Struct, Ty,
 };
 
 fn try_get_resolver_for_node(
@@ -37,24 +37,34 @@ fn try_get_resolver_for_node(
     file_id: FileId,
     node: &SyntaxNode,
 ) -> Option<Resolver> {
-    if let Some(module) = ast::Module::cast(node.clone()) {
-        let src = crate::Source { file_id: file_id.into(), ast: module };
-        Some(crate::Module::from_declaration(db, src)?.resolver(db))
-    } else if let Some(file) = ast::SourceFile::cast(node.clone()) {
-        let src =
-            crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(file) };
-        Some(crate::Module::from_definition(db, src)?.resolver(db))
-    } else if let Some(s) = ast::StructDef::cast(node.clone()) {
-        let src = crate::Source { file_id: file_id.into(), ast: s };
-        Some(Struct::from_source(db, src)?.resolver(db))
-    } else if let Some(e) = ast::EnumDef::cast(node.clone()) {
-        let src = crate::Source { file_id: file_id.into(), ast: e };
-        Some(Enum::from_source(db, src)?.resolver(db))
-    } else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
-        Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
-    } else {
-        // FIXME add missing cases
-        None
+    match_ast! {
+        match node {
+            ast::Module(it) => {
+                let src = crate::Source { file_id: file_id.into(), ast: it };
+                Some(crate::Module::from_declaration(db, src)?.resolver(db))
+            },
+             ast::SourceFile(it) => {
+                let src =
+                    crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(it) };
+                Some(crate::Module::from_definition(db, src)?.resolver(db))
+            },
+            ast::StructDef(it) => {
+                let src = crate::Source { file_id: file_id.into(), ast: it };
+                Some(Struct::from_source(db, src)?.resolver(db))
+            },
+            ast::EnumDef(it) => {
+                let src = crate::Source { file_id: file_id.into(), ast: it };
+                Some(Enum::from_source(db, src)?.resolver(db))
+            },
+            _ => {
+                if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
+                    Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
+                } else {
+                    // FIXME add missing cases
+                    None
+                }
+            },
+        }
     }
 }
 
@@ -68,16 +78,14 @@ fn def_with_body_from_child_node(
     let ctx = LocationCtx::new(db, module.id, file_id.into());
 
     node.ancestors().find_map(|node| {
-        if let Some(def) = ast::FnDef::cast(node.clone()) {
-            return Some(Function { id: ctx.to_def(&def) }.into());
-        }
-        if let Some(def) = ast::ConstDef::cast(node.clone()) {
-            return Some(Const { id: ctx.to_def(&def) }.into());
-        }
-        if let Some(def) = ast::StaticDef::cast(node) {
-            return Some(Static { id: ctx.to_def(&def) }.into());
+        match_ast! {
+            match node {
+                ast::FnDef(def)  => { Some(Function {id: ctx.to_def(&def) }.into()) },
+                ast::ConstDef(def) => { Some(Const { id: ctx.to_def(&def) }.into()) },
+                ast::StaticDef(def) => { Some(Static { id: ctx.to_def(&def) }.into()) },
+                _ => { None },
+            }
         }
-        None
     })
 }
 
@@ -245,9 +253,14 @@ impl SourceAnalyzer {
             Some(res)
         });
 
-        let items =
-            self.resolver.resolve_module_path(db, &path).take_types().map(PathResolution::Def);
-        types.or(values).or(items)
+        let items = self
+            .resolver
+            .resolve_module_path(db, &path)
+            .take_types()
+            .map(|it| PathResolution::Def(it.into()));
+        types.or(values).or(items).or_else(|| {
+            self.resolver.resolve_path_as_macro(db, &path).map(|def| PathResolution::Macro(def))
+        })
     }
 
     pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
@@ -317,16 +330,42 @@ impl SourceAnalyzer {
         db: &impl HirDatabase,
         ty: Ty,
         name: Option<&Name>,
-        callback: impl FnMut(&Ty, Function) -> Option<T>,
+        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
+    ) -> Option<T> {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        // FIXME replace Unknown by bound vars here
+        let canonical = crate::ty::Canonical { value: ty, num_vars: 0 };
+        method_resolution::iterate_method_candidates(
+            &canonical,
+            db,
+            &self.resolver,
+            name,
+            method_resolution::LookupMode::MethodCall,
+            |ty, it| match it {
+                AssocItem::Function(f) => callback(ty, f),
+                _ => None,
+            },
+        )
+    }
+
+    pub fn iterate_path_candidates<T>(
+        &self,
+        db: &impl HirDatabase,
+        ty: Ty,
+        name: Option<&Name>,
+        callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
     ) -> Option<T> {
         // There should be no inference vars in types passed here
         // FIXME check that?
+        // FIXME replace Unknown by bound vars here
         let canonical = crate::ty::Canonical { value: ty, num_vars: 0 };
-        crate::ty::method_resolution::iterate_method_candidates(
+        method_resolution::iterate_method_candidates(
             &canonical,
             db,
             &self.resolver,
             name,
+            method_resolution::LookupMode::Path,
             callback,
         )
     }