16 files changed, 247 insertions, 236 deletions

diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index fbd499900..783305005 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,
@@ -109,9 +109,6 @@ impl Completions {
         local_name: hir::Name,
         resolution: &hir::ScopeDef,
     ) {
-        if ctx.expects_type() && resolution.is_value_def() {
-            return;
-        }
         self.add_opt(render_resolution(RenderContext::new(ctx), local_name, resolution));
     }
 
@@ -134,9 +131,6 @@ impl Completions {
         func: hir::Function,
         local_name: Option<hir::Name>,
     ) {
-        if ctx.expects_type() {
-            return;
-        }
         self.add_opt(render_fn(RenderContext::new(ctx), None, local_name, func));
     }
 
@@ -178,9 +172,6 @@ impl Completions {
     }
 
     pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
-        if ctx.expects_type() {
-            return;
-        }
         self.add_opt(render_const(RenderContext::new(ctx), constant));
     }
 
@@ -188,6 +179,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,
@@ -204,32 +203,30 @@ impl Completions {
         variant: hir::Variant,
         local_name: Option<hir::Name>,
     ) {
-        if ctx.expects_type() {
-            return;
-        }
         let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
         self.add(item);
     }
 }
 
+/// Calls the callback for each variant of the provided enum with the path to the variant.
 fn complete_enum_variants(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    enum_data: hir::Enum,
+    enum_: hir::Enum,
     cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
 ) {
-    let variants = enum_data.variants(ctx.db);
+    let variants = enum_.variants(ctx.db);
 
     let module = if let Some(module) = ctx.scope.module() {
         // Compute path from the completion site if available.
         module
     } else {
         // Otherwise fall back to the enum's definition site.
-        enum_data.module(ctx.db)
+        enum_.module(ctx.db)
     };
 
     if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
-        if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_data)) {
+        if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
             for &variant in &variants {
                 let self_path = hir::ModPath::from_segments(
                     hir::PathKind::Plain,
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index 7f76e357e..6df569c2a 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -219,7 +219,7 @@ static KIND_TO_ATTRIBUTES: Lazy<FxHashMap<SyntaxKind, &[&str]>> = Lazy::new(|| {
 });
 const EXPR_ATTRIBUTES: &[&str] = attrs!();
 
-/// https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
+/// <https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index>
 // Keep these sorted for the binary search!
 const ATTRIBUTES: &[AttrCompletion] = &[
     attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
diff --git a/crates/ide_completion/src/completions/attribute/derive.rs b/crates/ide_completion/src/completions/attribute/derive.rs
index d526824fb..7b3133e53 100644
--- a/crates/ide_completion/src/completions/attribute/derive.rs
+++ b/crates/ide_completion/src/completions/attribute/derive.rs
@@ -93,57 +93,20 @@ mod tests {
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn empty_derive() {
-        check(
-            r#"#[derive($0)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at PartialEq
-                at PartialEq, Eq
-                at PartialEq, PartialOrd
-                at PartialEq, Eq, PartialOrd, Ord
-            "#]],
-        );
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive($0)] struct Test;"#, expect![[r#""#]]);
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn derive_with_input() {
-        check(
-            r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at Eq
-                at PartialOrd
-                at Eq, PartialOrd, Ord
-            "#]],
-        )
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#, expect![[r#""#]])
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn derive_with_input2() {
-        check(
-            r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at Eq
-                at PartialOrd
-                at Eq, PartialOrd, Ord
-            "#]],
-        )
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#, expect![[r#""#]])
     }
 }
diff --git a/crates/ide_completion/src/completions/dot.rs b/crates/ide_completion/src/completions/dot.rs
index 8ad57a069..9552875c1 100644
--- a/crates/ide_completion/src/completions/dot.rs
+++ b/crates/ide_completion/src/completions/dot.rs
@@ -13,7 +13,7 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
         _ => return complete_undotted_self(acc, ctx),
     };
 
-    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
+    let receiver_ty = match ctx.sema.type_of_expr(dot_receiver) {
         Some(ty) => ty,
         _ => return,
     };
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/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index ba13d3707..0fccbeccf 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -536,17 +536,11 @@ Some multi-line comment$0
     fn test_completion_await_impls_future() {
         check(
             r#"
-//- /main.rs crate:main deps:std
-use std::future::*;
+//- minicore: future
+use core::future::*;
 struct A {}
 impl Future for A {}
 fn foo(a: A) { a.$0 }
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {}
-}
 "#,
             expect![[r#"
                 kw await expr.await
@@ -555,20 +549,12 @@ pub mod future {
 
         check(
             r#"
-//- /main.rs crate:main deps:std
+//- minicore: future
 use std::future::*;
 fn foo() {
     let a = async {};
     a.$0
 }
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {
-        type Output;
-    }
-}
 "#,
             expect![[r#"
                 kw await expr.await
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index 86eb21714..9f98b21be 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -34,7 +34,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 
     let receiver_text = get_receiver_text(dot_receiver, receiver_is_ambiguous_float_literal);
 
-    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
+    let receiver_ty = match ctx.sema.type_of_expr(dot_receiver) {
         Some(it) => it,
         None => return,
     };
@@ -50,7 +50,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 postfix_snippet(
                     ctx,
                     cap,
-                    &dot_receiver,
+                    dot_receiver,
                     "ifl",
                     "if let Ok {}",
                     &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
@@ -60,7 +60,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 postfix_snippet(
                     ctx,
                     cap,
-                    &dot_receiver,
+                    dot_receiver,
                     "while",
                     "while let Ok {}",
                     &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
@@ -71,7 +71,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 postfix_snippet(
                     ctx,
                     cap,
-                    &dot_receiver,
+                    dot_receiver,
                     "ifl",
                     "if let Some {}",
                     &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
@@ -81,7 +81,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 postfix_snippet(
                     ctx,
                     cap,
-                    &dot_receiver,
+                    dot_receiver,
                     "while",
                     "while let Some {}",
                     &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
@@ -93,7 +93,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         postfix_snippet(
             ctx,
             cap,
-            &dot_receiver,
+            dot_receiver,
             "if",
             "if expr {}",
             &format!("if {} {{\n    $0\n}}", receiver_text),
@@ -102,22 +102,22 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         postfix_snippet(
             ctx,
             cap,
-            &dot_receiver,
+            dot_receiver,
             "while",
             "while expr {}",
             &format!("while {} {{\n    $0\n}}", receiver_text),
         )
         .add_to(acc);
-        postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
+        postfix_snippet(ctx, cap, dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
             .add_to(acc);
     }
 
-    postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
+    postfix_snippet(ctx, cap, dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
         .add_to(acc);
     postfix_snippet(
         ctx,
         cap,
-        &dot_receiver,
+        dot_receiver,
         "refm",
         "&mut expr",
         &format!("&mut {}", receiver_text),
diff --git a/crates/ide_completion/src/completions/postfix/format_like.rs b/crates/ide_completion/src/completions/postfix/format_like.rs
index 9ebe1dcc0..2dc13c293 100644
--- a/crates/ide_completion/src/completions/postfix/format_like.rs
+++ b/crates/ide_completion/src/completions/postfix/format_like.rs
@@ -53,7 +53,7 @@ pub(crate) fn add_format_like_completions(
         for (label, macro_name) in KINDS {
             let snippet = parser.into_suggestion(macro_name);
 
-            postfix_snippet(ctx, cap, &dot_receiver, label, macro_name, &snippet).add_to(acc);
+            postfix_snippet(ctx, cap, dot_receiver, label, macro_name, &snippet).add_to(acc);
         }
     }
 }
@@ -91,7 +91,7 @@ enum State {
 impl FormatStrParser {
     pub(crate) fn new(input: String) -> Self {
         Self {
-            input: input,
+            input,
             output: String::new(),
             extracted_expressions: Vec::new(),
             state: State::NotExpr,
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index 58d4dd9ee..1643eeed4 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -15,10 +15,11 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         None => return,
     };
 
-    let resolution = match ctx.sema.resolve_path(&path) {
+    let resolution = match ctx.sema.resolve_path(path) {
         Some(res) => res,
         None => return,
     };
+
     let context_module = ctx.scope.module();
 
     if ctx.expects_item() || ctx.expects_assoc_item() {
@@ -60,21 +61,31 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     }
                 }
 
-                if let hir::ScopeDef::MacroDef(macro_def) = def {
-                    if !macro_def.is_fn_like() {
-                        // Don't suggest attribute macros and derives.
-                        continue;
+                let add_resolution = match def {
+                    // Don't suggest attribute macros and derives.
+                    hir::ScopeDef::MacroDef(mac) => mac.is_fn_like(),
+                    // no values in type places
+                    hir::ScopeDef::ModuleDef(hir::ModuleDef::Function(_))
+                    | hir::ScopeDef::ModuleDef(hir::ModuleDef::Variant(_))
+                    | hir::ScopeDef::ModuleDef(hir::ModuleDef::Static(_))
+                    | hir::ScopeDef::Local(_) => !ctx.expects_type(),
+                    // unless its a constant in a generic arg list position
+                    hir::ScopeDef::ModuleDef(hir::ModuleDef::Const(_)) => {
+                        !ctx.expects_type() || ctx.expects_generic_arg()
                     }
-                }
+                    _ => true,
+                };
 
-                acc.add_resolution(ctx, name, &def);
+                if add_resolution {
+                    acc.add_resolution(ctx, name, &def);
+                }
             }
         }
         hir::PathResolution::Def(def @ hir::ModuleDef::Adt(_))
         | hir::PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_))
         | hir::PathResolution::Def(def @ hir::ModuleDef::BuiltinType(_)) => {
             if let hir::ModuleDef::Adt(hir::Adt::Enum(e)) = def {
-                add_enum_variants(ctx, acc, e);
+                add_enum_variants(acc, ctx, e);
             }
             let ty = match def {
                 hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
@@ -82,7 +93,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     let ty = a.ty(ctx.db);
                     if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
                         cov_mark::hit!(completes_variant_through_alias);
-                        add_enum_variants(ctx, acc, e);
+                        add_enum_variants(acc, ctx, e);
                     }
                     ty
                 }
@@ -107,11 +118,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                         return None;
                     }
-                    match item {
-                        hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
-                        hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                    }
+                    add_assoc_item(acc, ctx, item);
                     None::<()>
                 });
 
@@ -133,11 +140,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                     continue;
                 }
-                match item {
-                    hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
-                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                }
+                add_assoc_item(acc, ctx, item);
             }
         }
         hir::PathResolution::TypeParam(_) | hir::PathResolution::SelfType(_) => {
@@ -149,7 +152,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 };
 
                 if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
-                    add_enum_variants(ctx, acc, e);
+                    add_enum_variants(acc, ctx, e);
                 }
 
                 let traits_in_scope = ctx.scope.traits_in_scope();
@@ -162,11 +165,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     // We might iterate candidates of a trait multiple times here, so deduplicate
                     // them.
                     if seen.insert(item) {
-                        match item {
-                            hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
-                            hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                            hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                        }
+                        add_assoc_item(acc, ctx, item);
                     }
                     None::<()>
                 });
@@ -176,10 +175,22 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
     }
 }
 
-fn add_enum_variants(ctx: &CompletionContext, acc: &mut Completions, e: hir::Enum) {
-    for variant in e.variants(ctx.db) {
-        acc.add_enum_variant(ctx, variant, None);
+fn add_assoc_item(acc: &mut Completions, ctx: &CompletionContext, item: hir::AssocItem) {
+    match item {
+        hir::AssocItem::Function(func) if !ctx.expects_type() => acc.add_function(ctx, func, None),
+        hir::AssocItem::Const(ct) if !ctx.expects_type() || ctx.expects_generic_arg() => {
+            acc.add_const(ctx, ct)
+        }
+        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+        _ => (),
+    }
+}
+
+fn add_enum_variants(acc: &mut Completions, ctx: &CompletionContext, e: hir::Enum) {
+    if ctx.expects_type() {
+        return;
     }
+    e.variants(ctx.db).into_iter().for_each(|variant| acc.add_enum_variant(ctx, variant, None));
 }
 
 #[cfg(test)]
@@ -927,4 +938,24 @@ fn main() {
             "#]],
         );
     }
+
+    #[test]
+    fn completes_types_and_const_in_arg_list() {
+        check(
+            r#"
+mod foo {
+    pub const CONST: () = ();
+    pub type Type = ();
+}
+
+struct Foo<T>(t);
+
+fn foo(_: Foo<foo::$0>) {}
+"#,
+            expect![[r#"
+                ta Type
+                ct CONST
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index b1e6b2b77..b5af1c810 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() {
@@ -35,21 +36,50 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
 
-    if let Some(hir::Adt::Enum(e)) =
-        ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
-    {
-        super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
-            acc.add_qualified_enum_variant(ctx, variant, path)
-        });
+    if !ctx.expects_type() {
+        if let Some(hir::Adt::Enum(e)) =
+            ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
+        {
+            super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
+                acc.add_qualified_enum_variant(ctx, variant, path)
+            });
+        }
+    }
+
+    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 {
+        if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) | ScopeDef::Label(_) =
+            res
+        {
             cov_mark::hit!(skip_lifetime_completion);
             return;
         }
         let add_resolution = match res {
+            // Don't suggest attribute macros and derives.
             ScopeDef::MacroDef(mac) => mac.is_fn_like(),
+            // no values in type places
+            ScopeDef::ModuleDef(hir::ModuleDef::Function(_))
+            | ScopeDef::ModuleDef(hir::ModuleDef::Variant(_))
+            | ScopeDef::ModuleDef(hir::ModuleDef::Static(_))
+            | ScopeDef::Local(_) => !ctx.expects_type(),
+            // unless its a constant in a generic arg list position
+            ScopeDef::ModuleDef(hir::ModuleDef::Const(_))
+            | ScopeDef::GenericParam(hir::GenericParam::ConstParam(_)) => {
+                !ctx.expects_type() || ctx.expects_generic_arg()
+            }
             _ => true,
         };
         if add_resolution {
@@ -777,4 +807,30 @@ $0
             "#]],
         )
     }
+
+    #[test]
+    fn completes_types_and_const_in_arg_list() {
+        check(
+            r#"
+enum Bar {
+    Baz
+}
+trait Foo {
+    type Bar;
+}
+
+const CONST: () = ();
+
+fn foo<T: Foo<$0>, const CONST_PARAM: usize>(_: T) {}
+"#,
+            expect![[r#"
+                ta Bar =       type Bar;
+                tp T
+                cp CONST_PARAM
+                tt Foo
+                en Bar
+                ct CONST
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 2c2a4aa6b..a8437d81c 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -276,6 +276,10 @@ impl<'a> CompletionContext<'a> {
         matches!(self.completion_location, Some(ImmediateLocation::ItemList))
     }
 
+    pub(crate) fn expects_generic_arg(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::GenericArgList(_)))
+    }
+
     pub(crate) fn has_block_expr_parent(&self) -> bool {
         matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
     }
@@ -380,7 +384,7 @@ impl<'a> CompletionContext<'a> {
                         (|| {
                             let expr_field = self.token.prev_sibling_or_token()?
                                       .into_node()
-                                      .and_then(|node| ast::RecordExprField::cast(node))?;
+                                      .and_then(ast::RecordExprField::cast)?;
                             let (_, _, ty) = self.sema.resolve_record_field(&expr_field)?;
                             Some((
                                 Some(ty),
@@ -467,7 +471,7 @@ impl<'a> CompletionContext<'a> {
         self.expected_type = expected_type;
         self.expected_name = expected_name;
 
-        let name_like = match find_node_at_offset(&&file_with_fake_ident, offset) {
+        let name_like = match find_node_at_offset(&file_with_fake_ident, offset) {
             Some(it) => it,
             None => return,
         };
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index ee87bf461..72e67e3c4 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
@@ -112,12 +115,12 @@ pub(crate) fn determine_location(
 ) -> Option<ImmediateLocation> {
     let node = match name_like {
         ast::NameLike::NameRef(name_ref) => {
-            if ast::RecordExprField::for_field_name(&name_ref).is_some() {
+            if ast::RecordExprField::for_field_name(name_ref).is_some() {
                 return sema
                     .find_node_at_offset_with_macros(original_file, offset)
                     .map(ImmediateLocation::RecordExpr);
             }
-            if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
+            if ast::RecordPatField::for_field_name_ref(name_ref).is_some() {
                 return sema
                     .find_node_at_offset_with_macros(original_file, offset)
                     .map(ImmediateLocation::RecordPat);
@@ -125,7 +128,7 @@ pub(crate) fn determine_location(
             maximize_name_ref(name_ref)
         }
         ast::NameLike::Name(name) => {
-            if ast::RecordPatField::for_field_name(&name).is_some() {
+            if ast::RecordPatField::for_field_name(name).is_some() {
                 return sema
                     .find_node_at_offset_with_macros(original_file, offset)
                     .map(ImmediateLocation::RecordPat);
@@ -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)
@@ -254,7 +259,7 @@ fn test_inside_impl_trait_block() {
 }
 
 pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
-    element.into_token().and_then(|it| previous_non_trivia_token(it))
+    element.into_token().and_then(previous_non_trivia_token)
 }
 
 /// Check if the token previous to the previous one is `for`.
@@ -262,8 +267,8 @@ pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
 pub(crate) fn for_is_prev2(element: SyntaxElement) -> bool {
     element
         .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .and_then(|it| previous_non_trivia_token(it))
+        .and_then(previous_non_trivia_token)
+        .and_then(previous_non_trivia_token)
         .filter(|it| it.kind() == T![for])
         .is_some()
 }
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index d3db55c35..2bd2c44d0 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -23,53 +23,6 @@ use crate::{
     render::{enum_variant::render_variant, function::render_fn, macro_::render_macro},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
 };
-
-pub(crate) fn render_field(
-    ctx: RenderContext<'_>,
-    receiver: Option<hir::Name>,
-    field: hir::Field,
-    ty: &hir::Type,
-) -> CompletionItem {
-    render_field_(ctx, receiver, field, ty)
-}
-
-pub(crate) fn render_tuple_field(
-    ctx: RenderContext<'_>,
-    receiver: Option<hir::Name>,
-    field: usize,
-    ty: &hir::Type,
-) -> CompletionItem {
-    render_tuple_field_(ctx, receiver, field, ty)
-}
-
-pub(crate) fn render_resolution(
-    ctx: RenderContext<'_>,
-    local_name: hir::Name,
-    resolution: &hir::ScopeDef,
-) -> Option<CompletionItem> {
-    render_resolution_(ctx, local_name, None, resolution)
-}
-
-pub(crate) fn render_resolution_with_import(
-    ctx: RenderContext<'_>,
-    import_edit: ImportEdit,
-) -> Option<CompletionItem> {
-    let resolution = hir::ScopeDef::from(import_edit.import.original_item);
-    if ctx.completion.expects_type() && resolution.is_value_def() {
-        return None;
-    }
-    let local_name = match resolution {
-        hir::ScopeDef::ModuleDef(hir::ModuleDef::Function(f)) => f.name(ctx.completion.db),
-        hir::ScopeDef::ModuleDef(hir::ModuleDef::Const(c)) => c.name(ctx.completion.db)?,
-        hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
-        _ => item_name(ctx.db(), import_edit.import.original_item)?,
-    };
-    render_resolution_(ctx, local_name, Some(import_edit), &resolution).map(|mut item| {
-        item.completion_kind = CompletionKind::Magic;
-        item
-    })
-}
-
 /// Interface for data and methods required for items rendering.
 #[derive(Debug)]
 pub(crate) struct RenderContext<'a> {
@@ -86,7 +39,7 @@ impl<'a> RenderContext<'a> {
     }
 
     fn db(&self) -> &'a RootDatabase {
-        &self.completion.db
+        self.completion.db
     }
 
     fn source_range(&self) -> TextRange {
@@ -122,7 +75,7 @@ impl<'a> RenderContext<'a> {
     }
 }
 
-fn render_field_(
+pub(crate) fn render_field(
     ctx: RenderContext<'_>,
     receiver: Option<hir::Name>,
     field: hir::Field,
@@ -135,7 +88,6 @@ fn render_field_(
         ctx.source_range(),
         receiver.map_or_else(|| name.clone(), |receiver| format!("{}.{}", receiver, name)),
     );
-
     item.set_relevance(CompletionRelevance {
         type_match: compute_type_match(ctx.completion, ty),
         exact_name_match: compute_exact_name_match(ctx.completion, &name),
@@ -146,17 +98,15 @@ fn render_field_(
         .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
         // For now we don't properly calculate the edits for ref match
         // completions on struct fields, so we've disabled them. See #8058.
     }
-
     item.build()
 }
 
-fn render_tuple_field_(
+pub(crate) fn render_tuple_field(
     ctx: RenderContext<'_>,
     receiver: Option<hir::Name>,
     field: usize,
@@ -167,14 +117,37 @@ fn render_tuple_field_(
         ctx.source_range(),
         receiver.map_or_else(|| field.to_string(), |receiver| format!("{}.{}", receiver, field)),
     );
-
     item.kind(SymbolKind::Field)
         .detail(ty.display(ctx.db()).to_string())
         .lookup_by(field.to_string());
-
     item.build()
 }
 
+pub(crate) fn render_resolution(
+    ctx: RenderContext<'_>,
+    local_name: hir::Name,
+    resolution: &hir::ScopeDef,
+) -> Option<CompletionItem> {
+    render_resolution_(ctx, local_name, None, resolution)
+}
+
+pub(crate) fn render_resolution_with_import(
+    ctx: RenderContext<'_>,
+    import_edit: ImportEdit,
+) -> Option<CompletionItem> {
+    let resolution = hir::ScopeDef::from(import_edit.import.original_item);
+    let local_name = match resolution {
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::Function(f)) => f.name(ctx.completion.db),
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::Const(c)) => c.name(ctx.completion.db)?,
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
+        _ => item_name(ctx.db(), import_edit.import.original_item)?,
+    };
+    render_resolution_(ctx, local_name, Some(import_edit), &resolution).map(|mut item| {
+        item.completion_kind = CompletionKind::Magic;
+        item
+    })
+}
+
 fn render_resolution_(
     ctx: RenderContext<'_>,
     local_name: hir::Name,
@@ -1007,6 +980,7 @@ fn go(world: &WorldSnapshot) { go(w$0) }
 
     #[test]
     fn too_many_arguments() {
+        cov_mark::check!(too_many_arguments);
         check_relevance(
             r#"
 struct Foo;
@@ -1151,16 +1125,11 @@ fn main() {
     fn suggest_deref() {
         check_relevance(
             r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct S;
 struct T(S);
 
-impl Deref for T {
+impl core::ops::Deref for T {
     type Target = S;
 
     fn deref(&self) -> &Self::Target {
@@ -1184,8 +1153,9 @@ fn main() {
                 st T []
                 st S []
                 fn main() []
-                tt Deref []
                 fn foo(…) []
+                md core []
+                tt Sized []
             "#]],
         )
     }
@@ -1194,21 +1164,11 @@ fn main() {
     fn suggest_deref_mut() {
         check_relevance(
             r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
-#[lang = "deref_mut"]
-pub trait DerefMut: Deref {
-    fn deref_mut(&mut self) -> &mut Self::Target;
-}
-
+//- minicore: deref_mut
 struct S;
 struct T(S);
 
-impl Deref for T {
+impl core::ops::Deref for T {
     type Target = S;
 
     fn deref(&self) -> &Self::Target {
@@ -1216,7 +1176,7 @@ impl Deref for T {
     }
 }
 
-impl DerefMut for T {
+impl core::ops::DerefMut for T {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
@@ -1235,12 +1195,12 @@ fn main() {
                 lc m [local]
                 lc t [local]
                 lc &mut t [type+local]
-                tt DerefMut []
-                tt Deref []
-                fn foo(…) []
                 st T []
                 st S []
                 fn main() []
+                fn foo(…) []
+                md core []
+                tt Sized []
             "#]],
         )
     }
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index 429d937c8..3a7238bb8 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -180,7 +180,7 @@ fn main() { frobnicate!(); }
 /// ```
 macro_rules! vec { () => {} }
 
-fn fn main() { v$0 }
+fn main() { v$0 }
 "#,
             r#"
 /// Creates a [`Vec`] containing the arguments.
@@ -193,7 +193,7 @@ fn fn main() { v$0 }
 /// ```
 macro_rules! vec { () => {} }
 
-fn fn main() { vec![$0] }
+fn main() { vec![$0] }
 "#,
         );
 
diff --git a/crates/ide_completion/src/render/pattern.rs b/crates/ide_completion/src/render/pattern.rs
index b4e80f424..3717a0409 100644
--- a/crates/ide_completion/src/render/pattern.rs
+++ b/crates/ide_completion/src/render/pattern.rs
@@ -75,10 +75,10 @@ fn render_pat(
 ) -> Option<String> {
     let mut pat = match kind {
         StructKind::Tuple if ctx.snippet_cap().is_some() => {
-            render_tuple_as_pat(&fields, &name, fields_omitted)
+            render_tuple_as_pat(fields, name, fields_omitted)
         }
         StructKind::Record => {
-            render_record_as_pat(ctx.db(), ctx.snippet_cap(), &fields, &name, fields_omitted)
+            render_record_as_pat(ctx.db(), ctx.snippet_cap(), fields, name, fields_omitted)
         }
         _ => return None,
     };
@@ -86,7 +86,7 @@ fn render_pat(
     if ctx.completion.is_param {
         pat.push(':');
         pat.push(' ');
-        pat.push_str(&name);
+        pat.push_str(name);
     }
     if ctx.snippet_cap().is_some() {
         pat.push_str("$0");
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)
     }