11 files changed, 150 insertions, 98 deletions

diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 7ab7f09fe..4f63ff0ef 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -4,7 +4,7 @@ use crate::{CompletionContext, Completions};
 
 /// Completes constats and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_pat_binding_or_const {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
         return;
     }
     if ctx.record_pat_syntax.is_some() {
@@ -14,20 +14,27 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
     ctx.scope.process_all_names(&mut |name, res| {
-        match &res {
-            hir::ScopeDef::ModuleDef(def) => match def {
-                hir::ModuleDef::Adt(hir::Adt::Enum(..))
-                | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                | hir::ModuleDef::EnumVariant(..)
-                | hir::ModuleDef::Const(..)
-                | hir::ModuleDef::Module(..) => (),
-                _ => return,
-            },
-            hir::ScopeDef::MacroDef(_) => (),
-            _ => return,
+        let add_resolution = match &res {
+            hir::ScopeDef::ModuleDef(def) => {
+                if ctx.is_irrefutable_let_pat_binding {
+                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
+                } else {
+                    matches!(
+                        def,
+                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
+                            | hir::ModuleDef::EnumVariant(..)
+                            | hir::ModuleDef::Const(..)
+                            | hir::ModuleDef::Module(..)
+                    )
+                }
+            }
+            hir::ScopeDef::MacroDef(_) => true,
+            _ => false,
         };
-
-        acc.add_resolution(ctx, name.to_string(), &res)
+        if add_resolution {
+            acc.add_resolution(ctx, name.to_string(), &res);
+        }
     });
 }
 
@@ -85,4 +92,26 @@ fn foo() {
             "#]],
         );
     }
+
+    #[test]
+    fn completes_in_irrefutable_let() {
+        check(
+            r#"
+enum E { X }
+use self::E::X;
+const Z: E = E::X;
+mod m {}
+
+static FOO: E = E::X;
+struct Bar { f: u32 }
+
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index 2049b9d09..eaa44c97d 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -1,5 +1,5 @@
 //! Complete fields in record literals and patterns.
-use assists::utils::FamousDefs;
+use ide_db::helpers::FamousDefs;
 use syntax::ast::Expr;
 
 use crate::{
@@ -45,8 +45,8 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 
 #[cfg(test)]
 mod tests {
-    use assists::utils::FamousDefs;
     use expect_test::{expect, Expect};
+    use ide_db::helpers::FamousDefs;
 
     use crate::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 86c143b63..81691cd7f 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,8 +1,8 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
-use assists::utils::ImportScope;
 use either::Either;
 use hir::{Adt, ModuleDef, ScopeDef, Type};
+use ide_db::helpers::insert_use::ImportScope;
 use ide_db::imports_locator;
 use syntax::AstNode;
 use test_utils::mark;
@@ -44,7 +44,9 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         acc.add_resolution(ctx, name.to_string(), &res)
     });
 
-    fuzzy_completion(acc, ctx).unwrap_or_default()
+    if ctx.config.enable_experimental_completions {
+        fuzzy_completion(acc, ctx).unwrap_or_default()
+    }
 }
 
 fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
@@ -79,32 +81,34 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
 
     let potential_import_name = ctx.token.to_string();
 
-    let possible_imports =
-        imports_locator::find_similar_imports(&ctx.sema, ctx.krate?, &potential_import_name, 400)
-            .filter_map(|import_candidate| match import_candidate {
-                // when completing outside the use declaration, modules are pretty useless
-                // and tend to bloat the completion suggestions a lot
-                Either::Left(ModuleDef::Module(_)) => None,
-                Either::Left(module_def) => Some((
-                    current_module.find_use_path(ctx.db, module_def)?,
-                    ScopeDef::ModuleDef(module_def),
-                )),
-                Either::Right(macro_def) => Some((
-                    current_module.find_use_path(ctx.db, macro_def)?,
-                    ScopeDef::MacroDef(macro_def),
-                )),
-            })
-            .filter(|(mod_path, _)| mod_path.len() > 1)
-            .filter_map(|(import_path, definition)| {
-                render_resolution_with_import(
-                    RenderContext::new(ctx),
-                    import_path.clone(),
-                    import_scope.clone(),
-                    ctx.config.merge,
-                    &definition,
-                )
-            })
-            .take(20);
+    let possible_imports = imports_locator::find_similar_imports(
+        &ctx.sema,
+        ctx.krate?,
+        &potential_import_name,
+        50,
+        true,
+    )
+    .filter_map(|import_candidate| {
+        Some(match import_candidate {
+            Either::Left(module_def) => {
+                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
+            }
+            Either::Right(macro_def) => {
+                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
+            }
+        })
+    })
+    .filter(|(mod_path, _)| mod_path.len() > 1)
+    .take(20)
+    .filter_map(|(import_path, definition)| {
+        render_resolution_with_import(
+            RenderContext::new(ctx),
+            import_path.clone(),
+            import_scope.clone(),
+            ctx.config.merge,
+            &definition,
+        )
+    });
 
     acc.add_all(possible_imports);
     Some(())
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
index 82874ff25..654a76f7b 100644
--- a/crates/completion/src/config.rs
+++ b/crates/completion/src/config.rs
@@ -4,11 +4,12 @@
 //! module, and we use to statically check that we only produce snippet
 //! completions if we are allowed to.
 
-use assists::utils::MergeBehaviour;
+use ide_db::helpers::insert_use::MergeBehaviour;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CompletionConfig {
     pub enable_postfix_completions: bool,
+    pub enable_experimental_completions: bool,
     pub add_call_parenthesis: bool,
     pub add_call_argument_snippets: bool,
     pub snippet_cap: Option<SnippetCap>,
@@ -30,6 +31,7 @@ impl Default for CompletionConfig {
     fn default() -> Self {
         CompletionConfig {
             enable_postfix_completions: true,
+            enable_experimental_completions: true,
             add_call_parenthesis: true,
             add_call_argument_snippets: true,
             snippet_cap: Some(SnippetCap { _private: () }),
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index bf70ee478..5cd11cf77 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -51,6 +51,7 @@ pub(crate) struct CompletionContext<'a> {
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
     pub(super) is_pat_binding_or_const: bool,
+    pub(super) is_irrefutable_let_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).
@@ -146,6 +147,7 @@ impl<'a> CompletionContext<'a> {
             active_parameter: ActiveParameter::at(db, position),
             is_param: false,
             is_pat_binding_or_const: false,
+            is_irrefutable_let_pat_binding: false,
             is_trivial_path: false,
             path_qual: None,
             after_if: false,
@@ -330,6 +332,7 @@ impl<'a> CompletionContext<'a> {
                         if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
                         {
                             self.is_pat_binding_or_const = false;
+                            self.is_irrefutable_let_pat_binding = true;
                         }
                     }
                 }
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index b13c3f376..e85549fef 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -2,8 +2,11 @@
 
 use std::fmt;
 
-use assists::utils::{insert_use, mod_path_to_ast, ImportScope, MergeBehaviour};
 use hir::{Documentation, ModPath, Mutability};
+use ide_db::helpers::{
+    insert_use::{self, ImportScope, MergeBehaviour},
+    mod_path_to_ast,
+};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
 
@@ -201,7 +204,7 @@ impl CompletionItem {
             trigger_call_info: None,
             score: None,
             ref_match: None,
-            import_data: None,
+            import_to_add: None,
         }
     }
 
@@ -255,13 +258,21 @@ impl CompletionItem {
     }
 }
 
+/// An extra import to add after the completion is applied.
+#[derive(Clone)]
+pub(crate) struct ImportToAdd {
+    pub(crate) import_path: ModPath,
+    pub(crate) import_scope: ImportScope,
+    pub(crate) merge_behaviour: Option<MergeBehaviour>,
+}
+
 /// A helper to make `CompletionItem`s.
 #[must_use]
 #[derive(Clone)]
 pub(crate) struct Builder {
     source_range: TextRange,
     completion_kind: CompletionKind,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
     label: String,
     insert_text: Option<String>,
     insert_text_format: InsertTextFormat,
@@ -278,14 +289,16 @@ pub(crate) struct Builder {
 
 impl Builder {
     pub(crate) fn build(self) -> CompletionItem {
+        let _p = profile::span("item::Builder::build");
+
         let mut label = self.label;
         let mut lookup = self.lookup;
         let mut insert_text = self.insert_text;
         let mut text_edits = TextEdit::builder();
 
-        if let Some((import_path, import_scope, merge_behaviour)) = self.import_data {
-            let import = mod_path_to_ast(&import_path);
-            let mut import_path_without_last_segment = import_path;
+        if let Some(import_data) = self.import_to_add {
+            let import = mod_path_to_ast(&import_data.import_path);
+            let mut import_path_without_last_segment = import_data.import_path;
             let _ = import_path_without_last_segment.segments.pop();
 
             if !import_path_without_last_segment.segments.is_empty() {
@@ -298,7 +311,11 @@ impl Builder {
                 label = format!("{}::{}", import_path_without_last_segment, label);
             }
 
-            let rewriter = insert_use(&import_scope, import, merge_behaviour);
+            let rewriter = insert_use::insert_use(
+                &import_data.import_scope,
+                import,
+                import_data.merge_behaviour,
+            );
             if let Some(old_ast) = rewriter.rewrite_root() {
                 algo::diff(&old_ast, &rewriter.rewrite(&old_ast)).into_text_edit(&mut text_edits);
             }
@@ -390,11 +407,8 @@ impl Builder {
         self.trigger_call_info = Some(true);
         self
     }
-    pub(crate) fn import_data(
-        mut self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> Builder {
-        self.import_data = import_data;
+    pub(crate) fn add_import(mut self, import_to_add: Option<ImportToAdd>) -> Builder {
+        self.import_to_add = import_to_add;
         self
     }
     pub(crate) fn set_ref_match(
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index ac57683fb..1ec2e9be7 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -69,6 +69,13 @@ pub use crate::{
 //     fn test_name() {}
 // }
 // ```
+//
+// And experimental completions, enabled with the `rust-analyzer.completion.enableExperimental` setting.
+// This flag enables or disables:
+//
+// - Auto import: additional completion options with automatic `use` import and options from all project importable items, matched for the input
+//
+// Experimental completions might cause issues with performance and completion list look.
 
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index e892d4de8..504757a6a 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -9,15 +9,15 @@ pub(crate) mod type_alias;
 
 mod builder_ext;
 
-use assists::utils::{ImportScope, MergeBehaviour};
 use hir::{Documentation, HasAttrs, HirDisplay, ModPath, Mutability, ScopeDef, Type};
+use ide_db::helpers::insert_use::{ImportScope, MergeBehaviour};
 use ide_db::RootDatabase;
 use syntax::TextRange;
 use test_utils::mark;
 
 use crate::{
-    config::SnippetCap, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
-    CompletionScore,
+    config::SnippetCap, item::ImportToAdd, CompletionContext, CompletionItem, CompletionItemKind,
+    CompletionKind, CompletionScore,
 };
 
 use crate::render::{enum_variant::render_enum_variant, function::render_fn, macro_::render_macro};
@@ -48,15 +48,15 @@ pub(crate) fn render_resolution<'a>(
 
 pub(crate) fn render_resolution_with_import<'a>(
     ctx: RenderContext<'a>,
-    import: ModPath,
+    import_path: ModPath,
     import_scope: ImportScope,
     merge_behaviour: Option<MergeBehaviour>,
     resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    let local_name = import.segments.last()?.to_string();
+    let local_name = import_path.segments.last()?.to_string();
     Render::new(ctx).render_resolution(
         local_name,
-        Some((import, import_scope, merge_behaviour)),
+        Some(ImportToAdd { import_path, import_scope, merge_behaviour }),
         resolution,
     )
 }
@@ -147,9 +147,10 @@ impl<'a> Render<'a> {
     fn render_resolution(
         self,
         local_name: String,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+        import_to_add: Option<ImportToAdd>,
         resolution: &ScopeDef,
     ) -> Option<CompletionItem> {
+        let _p = profile::span("render_resolution");
         use hir::ModuleDef::*;
 
         let completion_kind = match resolution {
@@ -159,15 +160,16 @@ impl<'a> Render<'a> {
 
         let kind = match resolution {
             ScopeDef::ModuleDef(Function(func)) => {
-                let item = render_fn(self.ctx, import_data, Some(local_name), *func);
+                let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
                 return Some(item);
             }
             ScopeDef::ModuleDef(EnumVariant(var)) => {
-                let item = render_enum_variant(self.ctx, import_data, Some(local_name), *var, None);
+                let item =
+                    render_enum_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                 return Some(item);
             }
             ScopeDef::MacroDef(mac) => {
-                let item = render_macro(self.ctx, import_data, local_name, *mac);
+                let item = render_macro(self.ctx, import_to_add, local_name, *mac);
                 return item;
             }
 
@@ -192,7 +194,7 @@ impl<'a> Render<'a> {
                     local_name,
                 )
                 .kind(CompletionItemKind::UnresolvedReference)
-                .import_data(import_data)
+                .add_import(import_to_add)
                 .build();
                 return Some(item);
             }
@@ -247,7 +249,7 @@ impl<'a> Render<'a> {
 
         let item = item
             .kind(kind)
-            .import_data(import_data)
+            .add_import(import_to_add)
             .set_documentation(docs)
             .set_ref_match(ref_match)
             .build();
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 6070e9b1d..f4bd02f25 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -1,23 +1,23 @@
 //! Renderer for `enum` variants.
 
-use assists::utils::{ImportScope, MergeBehaviour};
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
 use itertools::Itertools;
 use test_utils::mark;
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
     render::{builder_ext::Params, RenderContext},
 };
 
 pub(crate) fn render_enum_variant<'a>(
     ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
     local_name: Option<String>,
     variant: hir::EnumVariant,
     path: Option<ModPath>,
 ) -> CompletionItem {
-    EnumVariantRender::new(ctx, local_name, variant, path).render(import_data)
+    let _p = profile::span("render_enum_variant");
+    EnumVariantRender::new(ctx, local_name, variant, path).render(import_to_add)
 }
 
 #[derive(Debug)]
@@ -62,10 +62,7 @@ impl<'a> EnumVariantRender<'a> {
         }
     }
 
-    fn render(
-        self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> CompletionItem {
+    fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
         let mut builder = CompletionItem::new(
             CompletionKind::Reference,
             self.ctx.source_range(),
@@ -74,7 +71,7 @@ impl<'a> EnumVariantRender<'a> {
         .kind(CompletionItemKind::EnumVariant)
         .set_documentation(self.variant.docs(self.ctx.db()))
         .set_deprecated(self.ctx.is_deprecated(self.variant))
-        .import_data(import_data)
+        .add_import(import_to_add)
         .detail(self.detail());
 
         if self.variant_kind == StructKind::Tuple {
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 9dd5cd18c..542383d7e 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -1,21 +1,21 @@
 //! Renderer for function calls.
 
-use assists::utils::{ImportScope, MergeBehaviour};
-use hir::{HasSource, ModPath, Type};
+use hir::{HasSource, Type};
 use syntax::{ast::Fn, display::function_declaration};
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
     render::{builder_ext::Params, RenderContext},
 };
 
 pub(crate) fn render_fn<'a>(
     ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
     local_name: Option<String>,
     fn_: hir::Function,
 ) -> CompletionItem {
-    FunctionRender::new(ctx, local_name, fn_).render(import_data)
+    let _p = profile::span("render_fn");
+    FunctionRender::new(ctx, local_name, fn_).render(import_to_add)
 }
 
 #[derive(Debug)]
@@ -38,10 +38,7 @@ impl<'a> FunctionRender<'a> {
         FunctionRender { ctx, name, fn_, ast_node }
     }
 
-    fn render(
-        self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> CompletionItem {
+    fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
         let params = self.params();
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())
@@ -49,7 +46,7 @@ impl<'a> FunctionRender<'a> {
             .set_deprecated(self.ctx.is_deprecated(self.fn_))
             .detail(self.detail())
             .add_call_parens(self.ctx.completion, self.name, params)
-            .import_data(import_data)
+            .add_import(import_to_add)
             .build()
     }
 
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index fead59e41..b4ab32c6e 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -1,22 +1,22 @@
 //! Renderer for macro invocations.
 
-use assists::utils::{ImportScope, MergeBehaviour};
-use hir::{Documentation, HasSource, ModPath};
+use hir::{Documentation, HasSource};
 use syntax::display::macro_label;
 use test_utils::mark;
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
     render::RenderContext,
 };
 
 pub(crate) fn render_macro<'a>(
     ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
     name: String,
     macro_: hir::MacroDef,
 ) -> Option<CompletionItem> {
-    MacroRender::new(ctx, name, macro_).render(import_data)
+    let _p = profile::span("render_macro");
+    MacroRender::new(ctx, name, macro_).render(import_to_add)
 }
 
 #[derive(Debug)]
@@ -38,10 +38,7 @@ impl<'a> MacroRender<'a> {
         MacroRender { ctx, name, macro_, docs, bra, ket }
     }
 
-    fn render(
-        &self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> Option<CompletionItem> {
+    fn render(&self, import_to_add: Option<ImportToAdd>) -> Option<CompletionItem> {
         // FIXME: Currently proc-macro do not have ast-node,
         // such that it does not have source
         if self.macro_.is_proc_macro() {
@@ -53,7 +50,7 @@ impl<'a> MacroRender<'a> {
                 .kind(CompletionItemKind::Macro)
                 .set_documentation(self.docs.clone())
                 .set_deprecated(self.ctx.is_deprecated(self.macro_))
-                .import_data(import_data)
+                .add_import(import_to_add)
                 .detail(self.detail());
 
         let needs_bang = self.needs_bang();