Merge #1194

1194: Pr 1190 r=matklad a=matklad



Co-authored-by: Andrea Pretto <[email protected]>
Co-authored-by: Aleksey Kladov <[email protected]>

1 files changed, 115 insertions, 5 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..2473e58b4 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -1,12 +1,122 @@
-use crate::completion::{Completions, CompletionContext};
+use rustc_hash::FxHashMap;
+use ra_text_edit::TextEditBuilder;
+use ra_syntax::{SmolStr, ast, AstNode};
+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));
+
+        // auto-import
+        // We fetch ident from the original file, because we need to pre-filter auto-imports
+        if ast::NameRef::cast(ctx.token.parent()).is_some() {
+            let import_resolver = ImportResolver::new();
+            let import_names = import_resolver.all_names(ctx.token.text());
+            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()
+                };
+
+                // Hack: copied this check form conv.rs beacause auto import can produce edits
+                // that invalidate assert in conv_with.
+                if edit
+                    .as_atoms()
+                    .iter()
+                    .filter(|atom| !ctx.source_range().is_subrange(&atom.delete))
+                    .all(|atom| ctx.source_range().intersection(&atom.delete).is_none())
+                {
+                    CompletionItem::new(
+                        CompletionKind::Reference,
+                        ctx.source_range(),
+                        build_import_label(&name, &path),
+                    )
+                    .text_edit(edit)
+                    .add_to(acc);
+                }
+            });
+        }
     }
-    let names = ctx.analyzer.all_names(ctx.db);
+}
 
-    names.into_iter().for_each(|(name, res)| acc.add_resolution(ctx, name.to_string(), &res));
+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);
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct ImportResolver {
+    // todo: use fst crate or something like that
+    dummy_names: Vec<(SmolStr, Vec<SmolStr>)>,
+}
+
+impl ImportResolver {
+    pub(crate) fn new() -> Self {
+        let dummy_names = vec![
+            (SmolStr::new("fmt"), vec![SmolStr::new("std"), SmolStr::new("fmt")]),
+            (SmolStr::new("io"), vec![SmolStr::new("std"), SmolStr::new("io")]),
+            (SmolStr::new("iter"), vec![SmolStr::new("std"), SmolStr::new("iter")]),
+            (SmolStr::new("hash"), vec![SmolStr::new("std"), SmolStr::new("hash")]),
+            (
+                SmolStr::new("Debug"),
+                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Debug")],
+            ),
+            (
+                SmolStr::new("Display"),
+                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Display")],
+            ),
+            (
+                SmolStr::new("Hash"),
+                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hash")],
+            ),
+            (
+                SmolStr::new("Hasher"),
+                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hasher")],
+            ),
+            (
+                SmolStr::new("Iterator"),
+                vec![SmolStr::new("std"), SmolStr::new("iter"), SmolStr::new("Iterator")],
+            ),
+        ];
+
+        ImportResolver { dummy_names }
+    }
+
+    // Returns a map of importable items filtered by name.
+    // The map associates item name with its full path.
+    // todo: should return Resolutions
+    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, Vec<SmolStr>> {
+        if name.len() > 1 {
+            self.dummy_names.iter().filter(|(n, _)| n.contains(name)).cloned().collect()
+        } else {
+            FxHashMap::default()
+        }
+    }
 }
 
 #[cfg(test)]