1 files changed, 112 insertions, 18 deletions

diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index bd955aa85..952f052a1 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -1,30 +1,32 @@
 //! 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_trivial_path {
-        return;
-    }
-    if ctx.is_path_disallowed() || ctx.expects_item() {
+    if ctx.is_path_disallowed() || !ctx.is_trivial_path() {
         return;
     }
 
-    if ctx.expects_assoc_item() {
-        ctx.scope.process_all_names(&mut |name, def| {
-            if let ScopeDef::MacroDef(macro_def) = def {
-                acc.add_macro(ctx, Some(name.clone()), macro_def);
+    if ctx.expects_item() || ctx.expects_assoc_item() {
+        // only show macros in {Assoc}ItemList
+        ctx.scope.process_all_names(&mut |name, res| {
+            if let hir::ScopeDef::MacroDef(mac) = res {
+                if mac.is_fn_like() {
+                    acc.add_macro(ctx, Some(name.clone()), mac);
+                }
             }
-            if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
-                acc.add_resolution(ctx, name, &def);
+            if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
+                acc.add_resolution(ctx, name, &res);
             }
         });
         return;
     }
 
     if ctx.expects_use_tree() {
+        // only show modules in a fresh UseTree
         cov_mark::hit!(only_completes_modules_in_import);
         ctx.scope.process_all_names(&mut |name, res| {
             if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
@@ -42,12 +44,32 @@ 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);
             return;
         }
-        acc.add_resolution(ctx, name, &res);
+        let add_resolution = match res {
+            ScopeDef::MacroDef(mac) => mac.is_fn_like(),
+            _ => true,
+        };
+        if add_resolution {
+            acc.add_resolution(ctx, name, &res);
+        }
     });
 }
 
@@ -70,6 +92,28 @@ mod tests {
     }
 
     #[test]
+    fn dont_complete_values_in_type_pos() {
+        check(
+            r#"
+const FOO: () = ();
+static BAR: () = ();
+enum Foo {
+    Bar
+}
+struct Baz;
+fn foo() {
+    let local = ();
+    let _: $0;
+}
+"#,
+            expect![[r#"
+                en Foo
+                st Baz
+            "#]],
+        );
+    }
+
+    #[test]
     fn only_completes_modules_in_import() {
         cov_mark::check!(only_completes_modules_in_import);
         check(
@@ -340,7 +384,6 @@ fn x() -> $0
 "#,
             expect![[r#"
                 st Foo
-                fn x() fn()
             "#]],
         );
     }
@@ -392,7 +435,6 @@ pub mod prelude {
 }
 "#,
             expect![[r#"
-                fn foo()  fn()
                 md std
                 st Option
             "#]],
@@ -428,6 +470,44 @@ mod macros {
     }
 
     #[test]
+    fn does_not_complete_non_fn_macros() {
+        check(
+            r#"
+#[rustc_builtin_macro]
+pub macro Clone {}
+
+fn f() {$0}
+"#,
+            expect![[r#"
+                fn f() fn()
+            "#]],
+        );
+        check(
+            r#"
+#[rustc_builtin_macro]
+pub macro Clone {}
+
+struct S;
+impl S {
+    $0
+}
+"#,
+            expect![[r#""#]],
+        );
+        check(
+            r#"
+#[rustc_builtin_macro]
+pub macro bench {}
+
+fn f() {$0}
+"#,
+            expect![[r#"
+                fn f() fn()
+            "#]],
+        );
+    }
+
+    #[test]
     fn completes_std_prelude_if_core_is_defined() {
         check(
             r#"
@@ -449,7 +529,6 @@ pub mod prelude {
 }
 "#,
             expect![[r#"
-                fn foo()  fn()
                 md std
                 md core
                 st String
@@ -510,7 +589,6 @@ macro_rules! foo { () => {} }
 fn main() { let x: $0 }
 "#,
             expect![[r#"
-                fn main()  fn()
                 ma foo!(…) macro_rules! foo
             "#]],
         );
@@ -693,12 +771,11 @@ impl MyStruct {
 "#,
             expect![[r#"
                 md bar
-                ma foo! macro_rules! foo
+                ma foo!(…) macro_rules! foo
             "#]],
         )
     }
 
-    // FIXME: The completions here currently come from `macro_in_item_position`, but they shouldn't
     #[test]
     fn completes_in_item_list() {
         check(
@@ -715,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
+            "#]],
+        );
+    }
 }