6 files changed, 74 insertions, 45 deletions

diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index e5ba92acd..0f154112a 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -9,6 +9,7 @@ use ra_syntax::{
 };
 use ra_db::SyntaxDatabase;
 use rustc_hash::{FxHashMap};
+use hir::source_binder;
 
 use crate::{
     db,
@@ -36,7 +37,7 @@ pub(crate) fn completions(
         original_file.reparse(&edit)
     };
 
-    let module = ctry!(hir::Module::guess_from_position(db, position)?);
+    let module = ctry!(source_binder::module_from_position(db, position)?);
 
     let mut res = Vec::new();
     let mut has_completions = false;
@@ -427,7 +428,7 @@ mod tests {
         // check_snippet_completion(r"
         //     <|>
         //     ",
-        //     r##"[CompletionItem { label: "tfn", lookup: None, snippet: Some("#[test]\nfn $1() {\n    $0\n}") }]"##,
+        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
         // );
         check_snippet_completion(r"
             #[cfg(test)]
@@ -435,7 +436,7 @@ mod tests {
                 <|>
             }
             ",
-            r##"[CompletionItem { label: "tfn", lookup: None, snippet: Some("#[test]\nfn $1() {\n    $0\n}") },
+            r##"[CompletionItem { label: "Test function", lookup: Some("tfn"), snippet: Some("#[test]\nfn ${1:feature}() {\n$0\n}") },
                  CompletionItem { label: "pub(crate)", lookup: None, snippet: Some("pub(crate) $0") }]"##,
         );
     }
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
index e1a2d5241..f483ed045 100644
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -163,7 +163,7 @@ fn complete_path(
     };
     let target_module = match def_id.resolve(db)? {
         Def::Module(it) => it,
-        Def::Item => return Ok(()),
+        _ => return Ok(()),
     };
     let module_scope = target_module.scope(db)?;
     let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
@@ -177,9 +177,15 @@ fn complete_path(
 
 fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
     acc.push(CompletionItem {
-        label: "tfn".to_string(),
-        lookup: None,
-        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
+        label: "Test function".to_string(),
+        lookup: Some("tfn".to_string()),
+        snippet: Some(
+            "#[test]\n\
+             fn ${1:feature}() {\n\
+             $0\n\
+             }"
+            .to_string(),
+        ),
     });
     acc.push(CompletionItem {
         label: "pub(crate)".to_string(),
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index df2ef293d..b8d774eb5 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use salsa::{self, Database};
 use ra_db::{LocationIntener, BaseDatabase};
-use hir::{self, DefId, DefLoc, FnId, SourceItemId};
+use hir::{self, DefId, DefLoc};
 
 use crate::{
     symbol_index,
@@ -15,7 +15,6 @@ pub(crate) struct RootDatabase {
 
 #[derive(Debug, Default)]
 struct IdMaps {
-    fns: LocationIntener<SourceItemId, FnId>,
     defs: LocationIntener<DefLoc, DefId>,
 }
 
@@ -58,12 +57,6 @@ impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
     }
 }
 
-impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
-    fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
-        &self.id_maps.fns
-    }
-}
-
 salsa::database_storage! {
     pub(crate) struct RootDatabaseStorage for RootDatabase {
         impl ra_db::FilesDatabase {
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index f5cb3550e..975afc145 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -16,6 +16,7 @@ use rustc_hash::FxHashSet;
 use salsa::{Database, ParallelDatabase};
 use hir::{
     self,
+    source_binder,
     FnSignatureInfo,
     Problem,
 };
@@ -166,7 +167,7 @@ impl AnalysisImpl {
     /// This return `Vec`: a module may be included from several places. We
     /// don't handle this case yet though, so the Vec has length at most one.
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        let descr = match hir::Module::guess_from_position(&*self.db, position)? {
+        let descr = match source_binder::module_from_position(&*self.db, position)? {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
@@ -185,15 +186,12 @@ impl AnalysisImpl {
     }
     /// Returns `Vec` for the same reason as `parent_module`
     pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        let descr = match hir::Module::guess_from_file_id(&*self.db, file_id)? {
+        let descr = match source_binder::module_from_file_id(&*self.db, file_id)? {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
         let root = descr.crate_root();
-        let file_id = root
-            .source()
-            .as_file()
-            .expect("root module always has a file as a source");
+        let file_id = root.source().file_id();
 
         let crate_graph = self.db.crate_graph();
         let crate_id = crate_graph.crate_id_for_crate_root(file_id);
@@ -212,12 +210,14 @@ impl AnalysisImpl {
         let file = self.db.source_file(position.file_id);
         let syntax = file.syntax();
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-            if let Some(fn_descr) =
-                hir::Function::guess_for_name_ref(&*self.db, position.file_id, name_ref)
-            {
+            if let Some(fn_descr) = source_binder::function_from_child_node(
+                &*self.db,
+                position.file_id,
+                name_ref.syntax(),
+            )? {
                 let scope = fn_descr.scope(&*self.db);
                 // First try to resolve the symbol locally
-                return if let Some(entry) = scope.resolve_local_name(name_ref) {
+                if let Some(entry) = scope.resolve_local_name(name_ref) {
                     let mut vec = vec![];
                     vec.push((
                         position.file_id,
@@ -227,18 +227,17 @@ impl AnalysisImpl {
                             kind: NAME,
                         },
                     ));
-                    Ok(vec)
-                } else {
-                    // If that fails try the index based approach.
-                    self.index_resolve(name_ref)
+                    return Ok(vec);
                 };
             }
+            // If that fails try the index based approach.
+            return self.index_resolve(name_ref);
         }
         if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
             if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                 if module.has_semi() {
                     let parent_module =
-                        hir::Module::guess_from_file_id(&*self.db, position.file_id)?;
+                        source_binder::module_from_file_id(&*self.db, position.file_id)?;
                     let child_name = module.name();
                     match (parent_module, child_name) {
                         (Some(parent_module), Some(child_name)) => {
@@ -260,11 +259,11 @@ impl AnalysisImpl {
         Ok(vec![])
     }
 
-    pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
+    pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
         let file = self.db.source_file(position.file_id);
         // Find the binding associated with the offset
-        let (binding, descr) = match find_binding(&self.db, &file, position) {
-            None => return Vec::new(),
+        let (binding, descr) = match find_binding(&self.db, &file, position)? {
+            None => return Ok(Vec::new()),
             Some(it) => it,
         };
 
@@ -277,25 +276,36 @@ impl AnalysisImpl {
                 .map(|ref_desc| (position.file_id, ref_desc.range)),
         );
 
-        return ret;
+        return Ok(ret);
 
         fn find_binding<'a>(
             db: &db::RootDatabase,
             source_file: &'a SourceFileNode,
             position: FilePosition,
-        ) -> Option<(ast::BindPat<'a>, hir::Function)> {
+        ) -> Cancelable<Option<(ast::BindPat<'a>, hir::Function)>> {
             let syntax = source_file.syntax();
             if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
-                let descr = hir::Function::guess_for_bind_pat(db, position.file_id, binding)?;
-                return Some((binding, descr));
+                let descr = ctry!(source_binder::function_from_child_node(
+                    db,
+                    position.file_id,
+                    binding.syntax(),
+                )?);
+                return Ok(Some((binding, descr)));
             };
-            let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
-            let descr = hir::Function::guess_for_name_ref(db, position.file_id, name_ref)?;
+            let name_ref = ctry!(find_node_at_offset::<ast::NameRef>(syntax, position.offset));
+            let descr = ctry!(source_binder::function_from_child_node(
+                db,
+                position.file_id,
+                name_ref.syntax(),
+            )?);
             let scope = descr.scope(db);
-            let resolved = scope.resolve_local_name(name_ref)?;
+            let resolved = ctry!(scope.resolve_local_name(name_ref));
             let resolved = resolved.ptr().resolve(source_file);
-            let binding = find_node_at_offset::<ast::BindPat>(syntax, resolved.range().end())?;
-            Some((binding, descr))
+            let binding = ctry!(find_node_at_offset::<ast::BindPat>(
+                syntax,
+                resolved.range().end()
+            ));
+            Ok(Some((binding, descr)))
         }
     }
 
@@ -320,7 +330,7 @@ impl AnalysisImpl {
                 fix: None,
             })
             .collect::<Vec<_>>();
-        if let Some(m) = hir::Module::guess_from_file_id(&*self.db, file_id)? {
+        if let Some(m) = source_binder::module_from_file_id(&*self.db, file_id)? {
             for (name_node, problem) in m.problems(&*self.db) {
                 let diag = match problem {
                     Problem::UnresolvedModule { candidate } => {
@@ -411,7 +421,9 @@ impl AnalysisImpl {
             if fs.kind == FN_DEF {
                 let fn_file = self.db.source_file(fn_file_id);
                 if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) {
-                    let descr = hir::Function::guess_from_source(&*self.db, fn_file_id, fn_def);
+                    let descr = ctry!(source_binder::function_from_source(
+                        &*self.db, fn_file_id, fn_def
+                    )?);
                     if let Some(descriptor) = descr.signature_info(&*self.db) {
                         // If we have a calling expression let's find which argument we are on
                         let mut current_parameter = None;
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 12df580ba..90528edfd 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -248,7 +248,7 @@ impl Analysis {
         self.imp.approximately_resolve_symbol(position)
     }
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
-        Ok(self.imp.find_all_refs(position))
+        self.imp.find_all_refs(position)
     }
     pub fn doc_comment_for(
         &self,
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index fbe89f444..71d20dbe9 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -19,6 +19,23 @@ fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
 }
 
 #[test]
+fn approximate_resolve_works_in_items() {
+    let (analysis, pos) = analysis_and_position(
+        "
+        //- /lib.rs
+        struct Foo;
+        enum E { X(Foo<|>) }
+    ",
+    );
+
+    let symbols = analysis.approximately_resolve_symbol(pos).unwrap();
+    assert_eq_dbg(
+        r#"[(FileId(1), FileSymbol { name: "Foo", node_range: [0; 11), kind: STRUCT_DEF })]"#,
+        &symbols,
+    );
+}
+
+#[test]
 fn test_resolve_module() {
     let (analysis, pos) = analysis_and_position(
         "