1 files changed, 24 insertions, 30 deletions

diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index 2e082705e..e5ba92acd 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -2,18 +2,16 @@ mod reference_completion;
 
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    algo::find_leaf_at_offset,
     algo::visit::{visitor_ctx, VisitorCtx},
     ast,
     AstNode, AtomEdit,
     SyntaxNodeRef,
 };
+use ra_db::SyntaxDatabase;
 use rustc_hash::{FxHashMap};
 
 use crate::{
-    db::{self, SyntaxDatabase},
-    descriptors::{DescriptorDatabase, module::ModuleSource},
-    input::{FilesDatabase},
+    db,
     Cancelable, FilePosition
 };
 
@@ -31,39 +29,21 @@ pub(crate) fn completions(
     db: &db::RootDatabase,
     position: FilePosition,
 ) -> Cancelable<Option<Vec<CompletionItem>>> {
-    let original_file = db.file_syntax(position.file_id);
+    let original_file = db.source_file(position.file_id);
     // Insert a fake ident to get a valid parse tree
     let file = {
         let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
         original_file.reparse(&edit)
     };
 
-    let leaf = match find_leaf_at_offset(original_file.syntax(), position.offset).left_biased() {
-        None => return Ok(None),
-        Some(it) => it,
-    };
-    let source_root_id = db.file_source_root(position.file_id);
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_source = ModuleSource::for_node(position.file_id, leaf);
-    let module_id = match module_tree.any_module_for_source(module_source) {
-        None => return Ok(None),
-        Some(it) => it,
-    };
+    let module = ctry!(hir::Module::guess_from_position(db, position)?);
 
     let mut res = Vec::new();
     let mut has_completions = false;
     // First, let's try to complete a reference to some declaration.
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
         has_completions = true;
-        reference_completion::completions(
-            &mut res,
-            db,
-            source_root_id,
-            &module_tree,
-            module_id,
-            &file,
-            name_ref,
-        )?;
+        reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
         // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
         if is_node::<ast::Param>(name_ref.syntax()) {
             param_completions(name_ref.syntax(), &mut res);
@@ -219,9 +199,9 @@ mod tests {
                 <|>
             }
             ",
-            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
-                   CompletionItem { label: "Baz", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
+                CompletionItem { label: "Foo", lookup: None, snippet: None },
+                CompletionItem { label: "Baz", lookup: None, snippet: None }]"#,
         );
     }
 
@@ -236,6 +216,20 @@ mod tests {
     }
 
     #[test]
+    fn test_completion_self_path() {
+        check_scope_completion(
+            r"
+            use self::m::<|>;
+
+            mod m {
+                struct Bar;
+            }
+            ",
+            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
+        );
+    }
+
+    #[test]
     fn test_completion_mod_scope_nested() {
         check_scope_completion(
             r"
@@ -245,8 +239,8 @@ mod tests {
                 fn quux() { <|> }
             }
             ",
-            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
+                CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
         );
     }