complete_import: add new import resolver infrastructure with some hardcoded importable name.

Changes complete_scope to support that.

2 files changed, 70 insertions, 8 deletions

diff --git a/crates/ra_ide_api/src/completion/complete_scope.rs b/crates/ra_ide_api/src/completion/complete_scope.rs
index fd256fc3b..63d475823 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -1,12 +1,57 @@
-use crate::completion::{Completions, CompletionContext};
+use ra_text_edit::TextEditBuilder;
+use ra_syntax::SmolStr;
+use ra_assists::auto_import;
+use crate::completion::{CompletionItem, Completions, CompletionKind, CompletionContext};
 
 pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path {
-        return;
+    if ctx.is_trivial_path {
+        let names = ctx.analyzer.all_names(ctx.db);
+        names.into_iter().for_each(|(name, res)| acc.add_resolution(ctx, name.to_string(), &res));
     }
-    let names = ctx.analyzer.all_names(ctx.db);
 
-    names.into_iter().for_each(|(name, res)| acc.add_resolution(ctx, name.to_string(), &res));
+    if let Some(name) = ctx.path_ident.as_ref() {
+        let import_names = ctx.analyzer.all_import_names(ctx.db, name);
+        import_names.into_iter().for_each(|(name, path)| {
+            let edit = {
+                let mut builder = TextEditBuilder::default();
+                builder.replace(ctx.source_range(), name.to_string());
+                auto_import::auto_import_text_edit(
+                    ctx.token.parent(),
+                    ctx.token.parent(),
+                    &path,
+                    &mut builder,
+                );
+                builder.finish()
+            };
+            CompletionItem::new(
+                CompletionKind::Reference,
+                ctx.source_range(),
+                build_import_label(&name, &path),
+            )
+            .text_edit(edit)
+            .add_to(acc)
+        });
+    }
+}
+
+fn build_import_label(name: &str, path: &Vec<SmolStr>) -> String {
+    let mut buf = String::with_capacity(64);
+    buf.push_str(name);
+    buf.push_str(" (");
+    fmt_import_path(path, &mut buf);
+    buf.push_str(")");
+    buf
+}
+
+fn fmt_import_path(path: &Vec<SmolStr>, buf: &mut String) {
+    let mut segments = path.iter();
+    if let Some(s) = segments.next() {
+        buf.push_str(&s);
+    }
+    for s in segments {
+        buf.push_str("::");
+        buf.push_str(&s);
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 359f2cffa..ca8f7900d 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -5,10 +5,10 @@ use ra_syntax::{
     algo::{find_token_at_offset, find_covering_element, find_node_at_offset},
     SyntaxKind::*,
 };
-use hir::source_binder;
 
-use crate::{db, FilePosition};
+use hir::{ source_binder, Name };
 
+use crate::{db, FilePosition};
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
@@ -27,8 +27,10 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_pat_binding: bool,
     /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
     pub(super) is_trivial_path: bool,
-    /// If not a trivial, path, the prefix (qualifier).
+    /// If not a trivial path, the prefix (qualifier).
     pub(super) path_prefix: Option<hir::Path>,
+    /// If a trivial path, the ident.
+    pub(super) path_ident: Option<Name>,
     pub(super) after_if: bool,
     /// `true` if we are a statement or a last expr in the block.
     pub(super) can_be_stmt: bool,
@@ -63,6 +65,7 @@ impl<'a> CompletionContext<'a> {
             is_pat_binding: false,
             is_trivial_path: false,
             path_prefix: None,
+            path_ident: None,
             after_if: false,
             can_be_stmt: false,
             is_new_item: false,
@@ -83,6 +86,18 @@ impl<'a> CompletionContext<'a> {
     }
 
     fn fill(&mut self, original_file: &'a SourceFile, offset: TextUnit) {
+        // We heed the original NameRef before the "intellijRulezz" hack
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(original_file.syntax(), offset)
+        {
+            if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
+                if let Some(path) = hir::Path::from_ast(path) {
+                    if let Some(ident) = path.as_ident() {
+                        self.path_ident = Some(ident.clone());
+                    }
+                }
+            }
+        }
+
         // Insert a fake ident to get a valid parse tree. We will use this file
         // to determine context, though the original_file will be used for
         // actual completion.
@@ -151,6 +166,7 @@ impl<'a> CompletionContext<'a> {
             Some(it) => it,
             None => return,
         };
+
         if let Some(segment) = ast::PathSegment::cast(parent) {
             let path = segment.parent_path();
             self.is_call = path
@@ -167,6 +183,7 @@ impl<'a> CompletionContext<'a> {
                     return;
                 }
             }
+
             if path.qualifier().is_none() {
                 self.is_trivial_path = true;