7 files changed, 98 insertions, 38 deletions

diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index fbd499900..bd90cefb2 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -29,7 +29,7 @@ use crate::{
         macro_::render_macro,
         pattern::{render_struct_pat, render_variant_pat},
         render_field, render_resolution, render_tuple_field,
-        type_alias::render_type_alias,
+        type_alias::{render_type_alias, render_type_alias_with_eq},
         RenderContext,
     },
     CompletionContext, CompletionItem, CompletionItemKind,
@@ -188,6 +188,14 @@ impl Completions {
         self.add_opt(render_type_alias(RenderContext::new(ctx), type_alias));
     }
 
+    pub(crate) fn add_type_alias_with_eq(
+        &mut self,
+        ctx: &CompletionContext,
+        type_alias: hir::TypeAlias,
+    ) {
+        self.add_opt(render_type_alias_with_eq(RenderContext::new(ctx), type_alias));
+    }
+
     pub(crate) fn add_qualified_enum_variant(
         &mut self,
         ctx: &CompletionContext,
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index c010cbbca..30b8d44bd 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -1,10 +1,10 @@
 //! Feature: completion with imports-on-the-fly
 //!
 //! When completing names in the current scope, proposes additional imports from other modules or crates,
-//! if they can be qualified in the scope and their name contains all symbols from the completion input.
+//! if they can be qualified in the scope, and their name contains all symbols from the completion input.
 //!
 //! To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent.
-//! If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the contaning is checked case-insensitively.
+//! If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the containing is checked case-insensitively.
 //!
 //! ```
 //! fn main() {
@@ -23,8 +23,8 @@
 //! ```
 //!
 //! Also completes associated items, that require trait imports.
-//! If any unresolved and/or partially-qualified path predeces the input, it will be taken into account.
-//! Currently, only the imports with their import path ending with the whole qialifier will be proposed
+//! If any unresolved and/or partially-qualified path precedes the input, it will be taken into account.
+//! Currently, only the imports with their import path ending with the whole qualifier will be proposed
 //! (no fuzzy matching for qualifier).
 //!
 //! ```
@@ -61,14 +61,14 @@
 //! }
 //! ```
 //!
-//! NOTE: currently, if an assoc item comes from a trait that's not currently imported and it also has an unresolved and/or partially-qualified path,
+//! NOTE: currently, if an assoc item comes from a trait that's not currently imported, and it also has an unresolved and/or partially-qualified path,
 //! no imports will be proposed.
 //!
 //! .Fuzzy search details
 //!
 //! To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
 //! (i.e. in `HashMap` in the `std::collections::HashMap` path).
-//! For the same reasons, avoids searching for any path imports for inputs with their length less that 2 symbols
+//! For the same reasons, avoids searching for any path imports for inputs with their length less than 2 symbols
 //! (but shows all associated items for any input length).
 //!
 //! .Import configuration
@@ -79,15 +79,15 @@
 //! .LSP and performance implications
 //!
 //! The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the `additionalTextEdits`
-//! (case sensitive) resolve client capability in its client capabilities.
+//! (case-sensitive) resolve client capability in its client capabilities.
 //! This way the server is able to defer the costly computations, doing them for a selected completion item only.
 //! For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
 //! which might be slow ergo the feature is automatically disabled.
 //!
 //! .Feature toggle
 //!
-//! The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.enableAutoimportCompletions` flag.
-//! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
+//! The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.autoimport.enable` flag.
+//! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corresponding
 //! capability enabled.
 
 use ide_db::helpers::{
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index b1e6b2b77..952f052a1 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -1,8 +1,9 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
 use hir::ScopeDef;
+use syntax::{ast, AstNode};
 
-use crate::{CompletionContext, Completions};
+use crate::{patterns::ImmediateLocation, CompletionContext, Completions};
 
 pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     if ctx.is_path_disallowed() || !ctx.is_trivial_path() {
@@ -43,6 +44,20 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         });
     }
 
+    if let Some(ImmediateLocation::GenericArgList(arg_list)) = &ctx.completion_location {
+        if let Some(path_seg) = arg_list.syntax().parent().and_then(ast::PathSegment::cast) {
+            if let Some(hir::PathResolution::Def(hir::ModuleDef::Trait(trait_))) =
+                ctx.sema.resolve_path(&path_seg.parent_path())
+            {
+                trait_.items(ctx.sema.db).into_iter().for_each(|it| {
+                    if let hir::AssocItem::TypeAlias(alias) = it {
+                        acc.add_type_alias_with_eq(ctx, alias)
+                    }
+                });
+            }
+        }
+    }
+
     ctx.scope.process_all_names(&mut |name, res| {
         if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
             cov_mark::hit!(skip_lifetime_completion);
@@ -777,4 +792,21 @@ $0
             "#]],
         )
     }
+
+    #[test]
+    fn completes_assoc_types_in_dynimpl_trait() {
+        check(
+            r#"
+trait Foo {
+    type Bar;
+}
+
+fn foo(_: impl Foo<B$0>) {}
+"#,
+            expect![[r#"
+                ta Bar =  type Bar;
+                tt Foo
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index ee87bf461..81d7a1a1d 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -47,6 +47,9 @@ pub(crate) enum ImmediateLocation {
         receiver_is_ambiguous_float_literal: bool,
     },
     // Original file ast node
+    // Only set from a type arg
+    GenericArgList(ast::GenericArgList),
+    // Original file ast node
     /// The record expr of the field name we are completing
     RecordExpr(ast::RecordExpr),
     // Original file ast node
@@ -159,7 +162,6 @@ pub(crate) fn determine_location(
             }
         }
     };
-
     let res = match_ast! {
         match parent {
             ast::IdentPat(_it) => ImmediateLocation::IdentPat,
@@ -174,6 +176,9 @@ pub(crate) fn determine_location(
                 Some(TRAIT) => ImmediateLocation::Trait,
                 _ => return None,
             },
+            ast::GenericArgList(_it) => sema
+                .find_node_at_offset_with_macros(original_file, offset)
+                .map(ImmediateLocation::GenericArgList)?,
             ast::Module(it) => {
                 if it.item_list().is_none() {
                     ImmediateLocation::ModDeclaration(it)
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 902df46ca..d3db55c35 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -111,7 +111,10 @@ impl<'a> RenderContext<'a> {
             hir::AssocItem::TypeAlias(it) => self.is_deprecated(it),
         };
         is_assoc_deprecated
-            || assoc.containing_trait(db).map(|trait_| self.is_deprecated(trait_)).unwrap_or(false)
+            || assoc
+                .containing_trait_or_trait_impl(db)
+                .map(|trait_| self.is_deprecated(trait_))
+                .unwrap_or(false)
     }
 
     fn docs(&self, node: impl HasAttrs) -> Option<hir::Documentation> {
@@ -132,16 +135,17 @@ fn render_field_(
         ctx.source_range(),
         receiver.map_or_else(|| name.clone(), |receiver| format!("{}.{}", receiver, name)),
     );
-    item.kind(SymbolKind::Field)
-        .detail(ty.display(ctx.db()).to_string())
-        .set_documentation(field.docs(ctx.db()))
-        .set_deprecated(is_deprecated);
 
     item.set_relevance(CompletionRelevance {
         type_match: compute_type_match(ctx.completion, ty),
         exact_name_match: compute_exact_name_match(ctx.completion, &name),
         ..CompletionRelevance::default()
     });
+    item.kind(SymbolKind::Field)
+        .detail(ty.display(ctx.db()).to_string())
+        .set_documentation(field.docs(ctx.db()))
+        .set_deprecated(is_deprecated)
+        .lookup_by(name);
 
     if let Some(_ref_match) = compute_ref_match(ctx.completion, ty) {
         // FIXME
@@ -164,7 +168,9 @@ fn render_tuple_field_(
         receiver.map_or_else(|| field.to_string(), |receiver| format!("{}.{}", receiver, field)),
     );
 
-    item.kind(SymbolKind::Field).detail(ty.display(ctx.db()).to_string());
+    item.kind(SymbolKind::Field)
+        .detail(ty.display(ctx.db()).to_string())
+        .lookup_by(field.to_string());
 
     item.build()
 }
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index 1abeed96d..1357b9f4a 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -58,29 +58,29 @@ impl<'a> FunctionRender<'a> {
         Some(FunctionRender { ctx, name, receiver, func: fn_, ast_node, is_method })
     }
 
-    fn render(mut self, import_to_add: Option<ImportEdit>) -> CompletionItem {
+    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
         let params = self.params();
-        if let Some(receiver) = &self.receiver {
-            self.name = format!("{}.{}", receiver, &self.name)
-        }
-        let mut item = CompletionItem::new(
-            CompletionKind::Reference,
-            self.ctx.source_range(),
-            self.name.clone(),
-        );
+        let call = if let Some(receiver) = &self.receiver {
+            format!("{}.{}", receiver, &self.name)
+        } else {
+            self.name.clone()
+        };
+        let mut item =
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), call.clone());
         item.kind(self.kind())
             .set_documentation(self.ctx.docs(self.func))
             .set_deprecated(
                 self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
             )
             .detail(self.detail())
-            .add_call_parens(self.ctx.completion, self.name.clone(), params)
-            .add_import(import_to_add);
+            .add_call_parens(self.ctx.completion, call.clone(), params)
+            .add_import(import_to_add)
+            .lookup_by(self.name);
 
         let ret_type = self.func.ret_type(self.ctx.db());
         item.set_relevance(CompletionRelevance {
             type_match: compute_type_match(self.ctx.completion, &ret_type),
-            exact_name_match: compute_exact_name_match(self.ctx.completion, &self.name),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, &call),
             ..CompletionRelevance::default()
         });
 
@@ -263,7 +263,7 @@ fn bar(s: &S) {
         );
 
         check_edit(
-            "self.foo",
+            "foo",
             r#"
 struct S {}
 impl S {
diff --git a/crates/ide_completion/src/render/type_alias.rs b/crates/ide_completion/src/render/type_alias.rs
index e47b4c745..e0234171a 100644
--- a/crates/ide_completion/src/render/type_alias.rs
+++ b/crates/ide_completion/src/render/type_alias.rs
@@ -16,7 +16,14 @@ pub(crate) fn render_type_alias<'a>(
     ctx: RenderContext<'a>,
     type_alias: hir::TypeAlias,
 ) -> Option<CompletionItem> {
-    TypeAliasRender::new(ctx, type_alias)?.render()
+    TypeAliasRender::new(ctx, type_alias)?.render(false)
+}
+
+pub(crate) fn render_type_alias_with_eq<'a>(
+    ctx: RenderContext<'a>,
+    type_alias: hir::TypeAlias,
+) -> Option<CompletionItem> {
+    TypeAliasRender::new(ctx, type_alias)?.render(true)
 }
 
 #[derive(Debug)]
@@ -32,8 +39,14 @@ impl<'a> TypeAliasRender<'a> {
         Some(TypeAliasRender { ctx, type_alias, ast_node })
     }
 
-    fn render(self) -> Option<CompletionItem> {
-        let name = self.name()?;
+    fn render(self, with_eq: bool) -> Option<CompletionItem> {
+        let name = self.ast_node.name().map(|name| {
+            if with_eq {
+                format!("{} = ", name.text())
+            } else {
+                name.text().to_string()
+            }
+        })?;
         let detail = self.detail();
 
         let mut item =
@@ -49,10 +62,6 @@ impl<'a> TypeAliasRender<'a> {
         Some(item.build())
     }
 
-    fn name(&self) -> Option<String> {
-        self.ast_node.name().map(|name| name.text().to_string())
-    }
-
     fn detail(&self) -> String {
         type_label(&self.ast_node)
     }