162 files changed, 3259 insertions, 1742 deletions

diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index 4e2a4fcd9..e93901cb3 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -3,7 +3,7 @@ use ide_db::helpers::{
     insert_use::{insert_use, ImportScope},
     mod_path_to_ast,
 };
-use syntax::ast;
+use syntax::{ast, AstNode, SyntaxNode};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 
@@ -82,25 +82,16 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let import_assets =
-        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
-            ImportAssets::for_regular_path(path_under_caret, &ctx.sema)
-        } else if let Some(method_under_caret) =
-            ctx.find_node_at_offset_with_descend::<ast::MethodCallExpr>()
-        {
-            ImportAssets::for_method_call(method_under_caret, &ctx.sema)
-        } else {
-            None
-        }?;
-    let proposed_imports = import_assets.search_for_imports(&ctx.sema, &ctx.config.insert_use);
+    let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
+    let proposed_imports =
+        import_assets.search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind);
     if proposed_imports.is_empty() {
         return None;
     }
 
-    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
+    let range = ctx.sema.original_range(&syntax_under_caret).range;
     let group = import_group_message(import_assets.import_candidate());
-    let scope =
-        ImportScope::find_insert_use_container(import_assets.syntax_under_caret(), &ctx.sema)?;
+    let scope = ImportScope::find_insert_use_container(&syntax_under_caret, &ctx.sema)?;
     for (import, _) in proposed_imports {
         acc.add_group(
             &group,
@@ -117,14 +108,28 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     Some(())
 }
 
+pub(super) fn find_importable_node(ctx: &AssistContext) -> Option<(ImportAssets, SyntaxNode)> {
+    if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
+        ImportAssets::for_exact_path(&path_under_caret, &ctx.sema)
+            .zip(Some(path_under_caret.syntax().clone()))
+    } else if let Some(method_under_caret) =
+        ctx.find_node_at_offset_with_descend::<ast::MethodCallExpr>()
+    {
+        ImportAssets::for_method_call(&method_under_caret, &ctx.sema)
+            .zip(Some(method_under_caret.syntax().clone()))
+    } else {
+        None
+    }
+}
+
 fn import_group_message(import_candidate: &ImportCandidate) -> GroupLabel {
     let name = match import_candidate {
-        ImportCandidate::Path(candidate) => format!("Import {}", &candidate.name),
+        ImportCandidate::Path(candidate) => format!("Import {}", candidate.name.text()),
         ImportCandidate::TraitAssocItem(candidate) => {
-            format!("Import a trait for item {}", &candidate.name)
+            format!("Import a trait for item {}", candidate.name.text())
         }
         ImportCandidate::TraitMethod(candidate) => {
-            format!("Import a trait for method {}", &candidate.name)
+            format!("Import a trait for method {}", candidate.name.text())
         }
     };
     GroupLabel(name)
diff --git a/crates/assists/src/handlers/generate_function.rs b/crates/assists/src/handlers/generate_function.rs
index 06ac85f67..1805c1dfd 100644
--- a/crates/assists/src/handlers/generate_function.rs
+++ b/crates/assists/src/handlers/generate_function.rs
@@ -158,11 +158,11 @@ impl FunctionBuilder {
                 it.text_range().end()
             }
             GeneratedFunctionTarget::InEmptyItemList(it) => {
-                let indent = IndentLevel::from_node(it.syntax());
+                let indent = IndentLevel::from_node(&it);
                 leading_ws = format!("\n{}", indent + 1);
                 fn_def = fn_def.indent(indent + 1);
                 trailing_ws = format!("\n{}", indent);
-                it.syntax().text_range().start() + TextSize::of('{')
+                it.text_range().start() + TextSize::of('{')
             }
         };
 
@@ -179,14 +179,14 @@ impl FunctionBuilder {
 
 enum GeneratedFunctionTarget {
     BehindItem(SyntaxNode),
-    InEmptyItemList(ast::ItemList),
+    InEmptyItemList(SyntaxNode),
 }
 
 impl GeneratedFunctionTarget {
     fn syntax(&self) -> &SyntaxNode {
         match self {
             GeneratedFunctionTarget::BehindItem(it) => it,
-            GeneratedFunctionTarget::InEmptyItemList(it) => it.syntax(),
+            GeneratedFunctionTarget::InEmptyItemList(it) => it,
         }
     }
 }
@@ -323,7 +323,16 @@ fn next_space_for_fn_in_module(
             if let Some(last_item) = it.item_list().and_then(|it| it.items().last()) {
                 GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
             } else {
-                GeneratedFunctionTarget::InEmptyItemList(it.item_list()?)
+                GeneratedFunctionTarget::InEmptyItemList(it.item_list()?.syntax().clone())
+            }
+        }
+        hir::ModuleSource::BlockExpr(it) => {
+            if let Some(last_item) =
+                it.statements().take_while(|stmt| matches!(stmt, ast::Stmt::Item(_))).last()
+            {
+                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
+            } else {
+                GeneratedFunctionTarget::InEmptyItemList(it.syntax().clone())
             }
         }
     };
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 9af45192b..827477272 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -1,6 +1,9 @@
 use itertools::Itertools;
 use stdx::format_to;
-use syntax::ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner};
+use syntax::{
+    ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner},
+    SmolStr,
+};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -49,16 +52,16 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
                 format_to!(buf, "{}", type_params.syntax());
             }
             buf.push_str(" ");
-            buf.push_str(name.text().as_str());
+            buf.push_str(name.text());
             if let Some(type_params) = type_params {
                 let lifetime_params = type_params
                     .lifetime_params()
                     .filter_map(|it| it.lifetime())
-                    .map(|it| it.text().clone());
+                    .map(|it| SmolStr::from(it.text()));
                 let type_params = type_params
                     .type_params()
                     .filter_map(|it| it.name())
-                    .map(|it| it.text().clone());
+                    .map(|it| SmolStr::from(it.text()));
 
                 let generic_params = lifetime_params.chain(type_params).format(", ");
                 format_to!(buf, "<{}>", generic_params)
diff --git a/crates/assists/src/handlers/generate_new.rs b/crates/assists/src/handlers/generate_new.rs
index 5c52b2bc8..b7390855a 100644
--- a/crates/assists/src/handlers/generate_new.rs
+++ b/crates/assists/src/handlers/generate_new.rs
@@ -3,7 +3,7 @@ use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
     ast::{self, AstNode, GenericParamsOwner, NameOwner, StructKind, VisibilityOwner},
-    T,
+    SmolStr, T,
 };
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -95,14 +95,14 @@ fn generate_impl_text(strukt: &ast::Struct, code: &str) -> String {
         format_to!(buf, "{}", type_params.syntax());
     }
     buf.push_str(" ");
-    buf.push_str(strukt.name().unwrap().text().as_str());
+    buf.push_str(strukt.name().unwrap().text());
     if let Some(type_params) = type_params {
         let lifetime_params = type_params
             .lifetime_params()
             .filter_map(|it| it.lifetime())
-            .map(|it| it.text().clone());
+            .map(|it| SmolStr::from(it.text()));
         let type_params =
-            type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
+            type_params.type_params().filter_map(|it| it.name()).map(|it| SmolStr::from(it.text()));
         format_to!(buf, "<{}>", lifetime_params.chain(type_params).format(", "))
     }
 
diff --git a/crates/assists/src/handlers/introduce_named_lifetime.rs b/crates/assists/src/handlers/introduce_named_lifetime.rs
index 3f5f44d69..02782eb6d 100644
--- a/crates/assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/assists/src/handlers/introduce_named_lifetime.rs
@@ -61,7 +61,7 @@ fn generate_fn_def_assist(
     // compute the location which implicitly has the same lifetime as the anonymous lifetime
     let loc_needing_lifetime = if let Some(self_param) = self_param {
         // if we have a self reference, use that
-        Some(self_param.self_token()?.text_range().start())
+        Some(self_param.name()?.syntax().text_range().start())
     } else {
         // otherwise, if there's a single reference parameter without a named liftime, use that
         let fn_params_without_lifetime: Vec<_> = param_list
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index a7d9fd4dc..b0b0d31b4 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,10 +1,7 @@
 use std::iter;
 
-use hir::AsName;
-use ide_db::helpers::{
-    import_assets::{ImportAssets, ImportCandidate},
-    mod_path_to_ast,
-};
+use hir::{AsAssocItem, AsName};
+use ide_db::helpers::{import_assets::ImportCandidate, mod_path_to_ast};
 use ide_db::RootDatabase;
 use syntax::{
     ast,
@@ -18,6 +15,8 @@ use crate::{
     AssistId, AssistKind, GroupLabel,
 };
 
+use super::auto_import::find_importable_node;
+
 // Assist: qualify_path
 //
 // If the name is unresolved, provides all possible qualified paths for it.
@@ -36,47 +35,38 @@ use crate::{
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let import_assets =
-        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
-            ImportAssets::for_regular_path(path_under_caret, &ctx.sema)
-        } else if let Some(method_under_caret) =
-            ctx.find_node_at_offset_with_descend::<ast::MethodCallExpr>()
-        {
-            ImportAssets::for_method_call(method_under_caret, &ctx.sema)
-        } else {
-            None
-        }?;
+    let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
     let proposed_imports = import_assets.search_for_relative_paths(&ctx.sema);
     if proposed_imports.is_empty() {
         return None;
     }
 
     let candidate = import_assets.import_candidate();
-    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
+    let range = ctx.sema.original_range(&syntax_under_caret).range;
 
     let qualify_candidate = match candidate {
         ImportCandidate::Path(candidate) => {
             if candidate.qualifier.is_some() {
                 mark::hit!(qualify_path_qualifier_start);
-                let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+                let path = ast::Path::cast(syntax_under_caret)?;
                 let (prev_segment, segment) = (path.qualifier()?.segment()?, path.segment()?);
                 QualifyCandidate::QualifierStart(segment, prev_segment.generic_arg_list())
             } else {
                 mark::hit!(qualify_path_unqualified_name);
-                let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+                let path = ast::Path::cast(syntax_under_caret)?;
                 let generics = path.segment()?.generic_arg_list();
                 QualifyCandidate::UnqualifiedName(generics)
             }
         }
         ImportCandidate::TraitAssocItem(_) => {
             mark::hit!(qualify_path_trait_assoc_item);
-            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+            let path = ast::Path::cast(syntax_under_caret)?;
             let (qualifier, segment) = (path.qualifier()?, path.segment()?);
             QualifyCandidate::TraitAssocItem(qualifier, segment)
         }
         ImportCandidate::TraitMethod(_) => {
             mark::hit!(qualify_path_trait_method);
-            let mcall_expr = ast::MethodCallExpr::cast(import_assets.syntax_under_caret().clone())?;
+            let mcall_expr = ast::MethodCallExpr::cast(syntax_under_caret)?;
             QualifyCandidate::TraitMethod(ctx.sema.db, mcall_expr)
         }
     };
@@ -140,7 +130,7 @@ impl QualifyCandidate<'_> {
         let generics =
             mcall_expr.generic_arg_list().as_ref().map_or_else(String::new, ToString::to_string);
         let arg_list = mcall_expr.arg_list().map(|arg_list| arg_list.args());
-        let trait_ = item_as_trait(item)?;
+        let trait_ = item_as_trait(db, item)?;
         let method = find_trait_method(db, trait_, &trait_method_name)?;
         if let Some(self_access) = method.self_param(db).map(|sp| sp.access(db)) {
             let receiver = match self_access {
@@ -179,11 +169,13 @@ fn find_trait_method(
     }
 }
 
-fn item_as_trait(item: hir::ItemInNs) -> Option<hir::Trait> {
-    if let hir::ModuleDef::Trait(trait_) = hir::ModuleDef::from(item.as_module_def_id()?) {
+fn item_as_trait(db: &RootDatabase, item: hir::ItemInNs) -> Option<hir::Trait> {
+    let item_module_def = hir::ModuleDef::from(item.as_module_def_id()?);
+
+    if let hir::ModuleDef::Trait(trait_) = item_module_def {
         Some(trait_)
     } else {
-        None
+        item_module_def.as_assoc_item(db)?.containing_trait(db)
     }
 }
 
@@ -191,7 +183,8 @@ fn group_label(candidate: &ImportCandidate) -> GroupLabel {
     let name = match candidate {
         ImportCandidate::Path(it) => &it.name,
         ImportCandidate::TraitAssocItem(it) | ImportCandidate::TraitMethod(it) => &it.name,
-    };
+    }
+    .text();
     GroupLabel(format!("Qualify {}", name))
 }
 
diff --git a/crates/assists/src/handlers/raw_string.rs b/crates/assists/src/handlers/raw_string.rs
index be963f162..d95267607 100644
--- a/crates/assists/src/handlers/raw_string.rs
+++ b/crates/assists/src/handlers/raw_string.rs
@@ -138,7 +138,7 @@ pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
         return None;
     }
 
-    let text = token.text().as_str();
+    let text = token.text();
     if !text.starts_with("r#") && text.ends_with('#') {
         return None;
     }
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index bd4c1c806..6aa9d2f2c 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -3,7 +3,7 @@ use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
     ast::{self, make, AstNode},
-    Direction, SmolStr,
+    Direction,
     SyntaxKind::{IDENT, WHITESPACE},
     TextSize,
 };
@@ -43,17 +43,18 @@ pub(crate) fn replace_derive_with_manual_impl(
 ) -> Option<()> {
     let attr = ctx.find_node_at_offset::<ast::Attr>()?;
 
-    let attr_name = attr
+    let has_derive = attr
         .syntax()
         .descendants_with_tokens()
         .filter(|t| t.kind() == IDENT)
         .find_map(syntax::NodeOrToken::into_token)
-        .filter(|t| t.text() == "derive")?
-        .text()
-        .clone();
+        .filter(|t| t.text() == "derive")
+        .is_some();
+    if !has_derive {
+        return None;
+    }
 
-    let trait_token =
-        ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?;
+    let trait_token = ctx.token_at_offset().find(|t| t.kind() == IDENT && t.text() != "derive")?;
     let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text())));
 
     let annotated_name = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?;
@@ -176,9 +177,9 @@ fn update_attribute(
         .syntax()
         .descendants_with_tokens()
         .filter(|t| t.kind() == IDENT)
-        .filter_map(|t| t.into_token().map(|t| t.text().clone()))
+        .filter_map(|t| t.into_token().map(|t| t.text().to_string()))
         .filter(|t| t != trait_name.text())
-        .collect::<Vec<SmolStr>>();
+        .collect::<Vec<_>>();
     let has_more_derives = !new_attr_input.is_empty();
 
     if has_more_derives {
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index fc9f83bab..44c35bafa 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -223,7 +223,7 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
             let method = mce.name_ref()?;
             let arg_list = mce.arg_list()?;
 
-            let method = match method.text().as_str() {
+            let method = match method.text() {
                 "is_some" => "is_none",
                 "is_none" => "is_some",
                 "is_ok" => "is_err",
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 2dd8fbe67..b5f7e4200 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -178,7 +178,7 @@ pub struct CrateData {
     pub root_file_id: FileId,
     pub edition: Edition,
     /// A name used in the package's project declaration: for Cargo projects,
-    /// it's [package].name, can be different for other project types or even
+    /// its `[package].name` can be different for other project types or even
     /// absent (a dummy crate for the code snippet, for example).
     ///
     /// For purposes of analysis, crates are anonymous (only names in
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index e5522980d..ab25a8c58 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -99,13 +99,14 @@ const ATTRIBUTES: &[AttrCompletion] = &[
         Some("export_name"),
         Some(r#"export_name = "${0:exported_symbol_name}""#),
     ),
+    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
     attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
     attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
     attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
     // FIXME: resolve through macro resolution?
     attr("global_allocator", None, None).prefer_inner(),
     attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
-    attr("inline(…)", Some("inline"), Some("inline(${0:lint})")),
+    attr("inline", Some("inline"), Some("inline")),
     attr("link", None, None),
     attr(r#"link_name = "…""#, Some("link_name"), Some(r#"link_name = "${0:symbol_name}""#)),
     attr(
@@ -468,10 +469,11 @@ struct Test {}
                 at deprecated
                 at derive(…)
                 at export_name = "…"
+                at doc(alias = "…")
                 at doc = "…"
                 at forbid(…)
                 at ignore = "…"
-                at inline(…)
+                at inline
                 at link
                 at link_name = "…"
                 at link_section = "…"
@@ -515,12 +517,13 @@ struct Test {}
                 at deprecated
                 at derive(…)
                 at export_name = "…"
+                at doc(alias = "…")
                 at doc = "…"
                 at feature(…)
                 at forbid(…)
                 at global_allocator
                 at ignore = "…"
-                at inline(…)
+                at inline
                 at link
                 at link_name = "…"
                 at link_section = "…"
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index 222809638..dc0b38a16 100644
--- a/crates/completion/src/completions/flyimport.rs
+++ b/crates/completion/src/completions/flyimport.rs
@@ -20,11 +20,14 @@
 //! # pub mod std { pub mod marker { pub struct PhantomData { } } }
 //! ```
 //!
+//! Also completes associated items, that require trait imports.
+//!
 //! .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 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 that 2 symbols
+//! (but shows all associated items for any input length).
 //!
 //! .Import configuration
 //!
@@ -45,10 +48,12 @@
 //! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
 //! capability enabled.
 
-use either::Either;
-use hir::{ModPath, ScopeDef};
-use ide_db::{helpers::insert_use::ImportScope, imports_locator};
-use syntax::AstNode;
+use hir::{AsAssocItem, ModPath, ScopeDef};
+use ide_db::helpers::{
+    import_assets::{ImportAssets, ImportCandidate},
+    insert_use::ImportScope,
+};
+use syntax::{AstNode, SyntaxNode, T};
 use test_utils::mark;
 
 use crate::{
@@ -60,58 +65,108 @@ use crate::{
 use super::Completions;
 
 pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    if !ctx.config.enable_autoimport_completions {
+    if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
     if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
         return None;
     }
-    let potential_import_name = ctx.token.to_string();
-    if potential_import_name.len() < 2 {
-        return None;
-    }
-    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.to_string());
+    let potential_import_name = {
+        let token_kind = ctx.token.kind();
+        if matches!(token_kind, T![.] | T![::]) {
+            String::new()
+        } else {
+            ctx.token.to_string()
+        }
+    };
 
-    let current_module = ctx.scope.module()?;
-    let anchor = ctx.name_ref_syntax.as_ref()?;
-    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.to_string());
 
     let user_input_lowercased = potential_import_name.to_lowercase();
-    let mut all_mod_paths = imports_locator::find_similar_imports(
+    let import_assets = import_assets(ctx, potential_import_name)?;
+    let import_scope = ImportScope::find_insert_use_container(
+        position_for_import(ctx, Some(import_assets.import_candidate()))?,
         &ctx.sema,
-        ctx.krate?,
-        Some(40),
-        potential_import_name,
-        true,
-        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))
-            }
+    )?;
+    let mut all_mod_paths = import_assets
+        .search_for_relative_paths(&ctx.sema)
+        .into_iter()
+        .map(|(mod_path, item_in_ns)| {
+            let scope_item = match item_in_ns {
+                hir::ItemInNs::Types(id) => ScopeDef::ModuleDef(id.into()),
+                hir::ItemInNs::Values(id) => ScopeDef::ModuleDef(id.into()),
+                hir::ItemInNs::Macros(id) => ScopeDef::MacroDef(id.into()),
+            };
+            (mod_path, scope_item)
         })
-    })
-    .filter(|(mod_path, _)| mod_path.len() > 1)
-    .collect::<Vec<_>>();
-
+        .collect::<Vec<_>>();
     all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
         compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
     });
 
     acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
-        render_resolution_with_import(
-            RenderContext::new(ctx),
-            ImportEdit { import_path, import_scope: import_scope.clone() },
-            &definition,
-        )
+        let import_for_trait_assoc_item = match definition {
+            ScopeDef::ModuleDef(module_def) => module_def
+                .as_assoc_item(ctx.db)
+                .and_then(|assoc| assoc.containing_trait(ctx.db))
+                .is_some(),
+            _ => false,
+        };
+        let import_edit = ImportEdit {
+            import_path,
+            import_scope: import_scope.clone(),
+            import_for_trait_assoc_item,
+        };
+        render_resolution_with_import(RenderContext::new(ctx), import_edit, &definition)
     }));
     Some(())
 }
 
+pub(crate) fn position_for_import<'a>(
+    ctx: &'a CompletionContext,
+    import_candidate: Option<&ImportCandidate>,
+) -> Option<&'a SyntaxNode> {
+    Some(match import_candidate {
+        Some(ImportCandidate::Path(_)) => ctx.name_ref_syntax.as_ref()?.syntax(),
+        Some(ImportCandidate::TraitAssocItem(_)) => ctx.path_qual.as_ref()?.syntax(),
+        Some(ImportCandidate::TraitMethod(_)) => ctx.dot_receiver.as_ref()?.syntax(),
+        None => ctx
+            .name_ref_syntax
+            .as_ref()
+            .map(|name_ref| name_ref.syntax())
+            .or_else(|| ctx.path_qual.as_ref().map(|path| path.syntax()))
+            .or_else(|| ctx.dot_receiver.as_ref().map(|expr| expr.syntax()))?,
+    })
+}
+
+fn import_assets(ctx: &CompletionContext, fuzzy_name: String) -> Option<ImportAssets> {
+    let current_module = ctx.scope.module()?;
+    if let Some(dot_receiver) = &ctx.dot_receiver {
+        ImportAssets::for_fuzzy_method_call(
+            current_module,
+            ctx.sema.type_of_expr(dot_receiver)?,
+            fuzzy_name,
+        )
+    } else {
+        let fuzzy_name_length = fuzzy_name.len();
+        let assets_for_path = ImportAssets::for_fuzzy_path(
+            current_module,
+            ctx.path_qual.clone(),
+            fuzzy_name,
+            &ctx.sema,
+        );
+
+        if matches!(assets_for_path.as_ref()?.import_candidate(), ImportCandidate::Path(_))
+            && fuzzy_name_length < 2
+        {
+            mark::hit!(ignore_short_input_for_path);
+            None
+        } else {
+            assets_for_path
+        }
+    }
+}
+
 fn compute_fuzzy_completion_order_key(
     proposed_mod_path: &ModPath,
     user_input_lowercased: &str,
@@ -224,6 +279,30 @@ fn main() {
     }
 
     #[test]
+    fn short_paths_are_ignored() {
+        mark::check!(ignore_short_input_for_path);
+
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    pub struct SecondStruct;
+    pub struct ThirdStruct;
+}
+
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+
+fn main() {
+    t$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+
+    #[test]
     fn fuzzy_completions_come_in_specific_order() {
         mark::check!(certain_fuzzy_order_test);
         check(
@@ -259,6 +338,176 @@ fn main() {
     }
 
     #[test]
+    fn trait_function_fuzzy_completion() {
+        let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            dep::test_mod::TestStruct::wei$0
+        }
+        "#;
+
+        check(
+            fixture,
+            expect![[r#"
+            fn weird_function() (dep::test_mod::TestTrait) fn weird_function()
+        "#]],
+        );
+
+        check_edit(
+            "weird_function",
+            fixture,
+            r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::weird_function()$0
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn trait_const_fuzzy_completion() {
+        let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            dep::test_mod::TestStruct::spe$0
+        }
+        "#;
+
+        check(
+            fixture,
+            expect![[r#"
+            ct SPECIAL_CONST (dep::test_mod::TestTrait)
+        "#]],
+        );
+
+        check_edit(
+            "SPECIAL_CONST",
+            fixture,
+            r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::SPECIAL_CONST
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn trait_method_fuzzy_completion() {
+        let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            let test_struct = dep::test_mod::TestStruct {};
+            test_struct.ran$0
+        }
+        "#;
+
+        check(
+            fixture,
+            expect![[r#"
+            me random_method() (dep::test_mod::TestTrait) fn random_method(&self)
+        "#]],
+        );
+
+        check_edit(
+            "random_method",
+            fixture,
+            r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.random_method()$0
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn no_trait_type_fuzzy_completion() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::hum$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+
+    #[test]
     fn does_not_propose_names_in_scope() {
         check(
             r#"
@@ -288,4 +537,131 @@ fn main() {
             expect![[r#""#]],
         );
     }
+
+    #[test]
+    fn does_not_propose_traits_in_scope() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+use dep::test_mod::{TestStruct, TestTrait};
+fn main() {
+    dep::test_mod::TestStruct::hum$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+
+    #[test]
+    fn blanket_trait_impl_import() {
+        check_edit(
+            "another_function",
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub struct TestStruct {}
+    pub trait TestTrait {
+        fn another_function();
+    }
+    impl<T> TestTrait for T {
+        fn another_function() {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::ano$0
+}
+"#,
+            r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::another_function()$0
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn zero_input_deprecated_assoc_item_completion() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.$0
+}
+        "#,
+            expect![[r#"
+                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self) DEPRECATED
+                "#]],
+        );
+
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::$0
+}
+"#,
+            expect![[r#"
+                ct SPECIAL_CONST (dep::test_mod::TestTrait) DEPRECATED
+                fn weird_function() (dep::test_mod::TestTrait) fn weird_function() DEPRECATED
+        "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/fn_param.rs b/crates/completion/src/completions/fn_param.rs
index 5505c3559..38e33a93e 100644
--- a/crates/completion/src/completions/fn_param.rs
+++ b/crates/completion/src/completions/fn_param.rs
@@ -6,7 +6,7 @@ use syntax::{
     match_ast, AstNode,
 };
 
-use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};
+use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
 /// Complete repeated parameters, both name and type. For example, if all
 /// functions in a file have a `spam: &mut Spam` parameter, a completion with
@@ -58,7 +58,7 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
         })
         .for_each(|(label, lookup)| {
             CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
-                .kind(crate::CompletionItemKind::Binding)
+                .kind(CompletionItemKind::Binding)
                 .lookup_by(lookup)
                 .add_to(acc)
         });
diff --git a/crates/completion/src/completions/mod_.rs b/crates/completion/src/completions/mod_.rs
index 00e951ca9..352fc7c77 100644
--- a/crates/completion/src/completions/mod_.rs
+++ b/crates/completion/src/completions/mod_.rs
@@ -3,11 +3,13 @@
 use std::iter;
 
 use hir::{Module, ModuleSource};
-use ide_db::base_db::{SourceDatabaseExt, VfsPath};
-use ide_db::RootDatabase;
+use ide_db::{
+    base_db::{SourceDatabaseExt, VfsPath},
+    RootDatabase, SymbolKind,
+};
 use rustc_hash::FxHashSet;
 
-use crate::{CompletionItem, CompletionItemKind};
+use crate::CompletionItem;
 
 use crate::{context::CompletionContext, item::CompletionKind, Completions};
 
@@ -79,7 +81,7 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
                 label.push(';');
             }
             CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
-                .kind(CompletionItemKind::Module)
+                .kind(SymbolKind::Module)
                 .add_to(acc)
         });
 
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index bb6354ded..0a7927eb8 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -1,10 +1,8 @@
 //! Complete fields in record literals and patterns.
-use ide_db::helpers::FamousDefs;
+use ide_db::{helpers::FamousDefs, SymbolKind};
 use syntax::ast::Expr;
 
-use crate::{
-    item::CompletionKind, CompletionContext, CompletionItem, CompletionItemKind, Completions,
-};
+use crate::{item::CompletionKind, CompletionContext, CompletionItem, Completions};
 
 pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
@@ -31,7 +29,7 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
                         "..Default::default()",
                     )
                     .insert_text(completion_text)
-                    .kind(CompletionItemKind::Field)
+                    .kind(SymbolKind::Field)
                     .build(),
                 );
             }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index 135ae49dc..f258ad9c3 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -32,7 +32,7 @@
 //! ```
 
 use hir::{self, HasAttrs, HasSource};
-use ide_db::traits::get_missing_assoc_items;
+use ide_db::{traits::get_missing_assoc_items, SymbolKind};
 use syntax::{
     ast::{self, edit, Impl},
     display::function_declaration,
@@ -152,7 +152,7 @@ fn add_function_impl(
     let completion_kind = if func.self_param(ctx.db).is_some() {
         CompletionItemKind::Method
     } else {
-        CompletionItemKind::Function
+        CompletionItemKind::SymbolKind(SymbolKind::Function)
     };
     let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
 
@@ -188,7 +188,7 @@ fn add_type_alias_impl(
     CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
         .text_edit(TextEdit::replace(range, snippet))
         .lookup_by(alias_name)
-        .kind(CompletionItemKind::TypeAlias)
+        .kind(SymbolKind::TypeAlias)
         .set_documentation(type_alias.docs(ctx.db))
         .add_to(acc);
 }
@@ -211,7 +211,7 @@ fn add_const_impl(
             CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
                 .text_edit(TextEdit::replace(range, snippet))
                 .lookup_by(const_name)
-                .kind(CompletionItemKind::Const)
+                .kind(SymbolKind::Const)
                 .set_documentation(const_.docs(ctx.db))
                 .add_to(acc);
         }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index ac5596ca4..a289efc34 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -29,6 +29,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     }
 
     ctx.scope.process_all_names(&mut |name, res| {
+        if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
+            mark::hit!(skip_lifetime_completion);
+            return;
+        }
         if ctx.use_item_syntax.is_some() {
             if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                 if name_ref.syntax().text() == name.to_string().as_str() {
@@ -37,7 +41,7 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
                 }
             }
         }
-        acc.add_resolution(ctx, name.to_string(), &res)
+        acc.add_resolution(ctx, name.to_string(), &res);
     });
 }
 
@@ -161,8 +165,8 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                bn y       i32
-                bn x       i32
+                lc y       i32
+                lc x       i32
                 fn quux(…) fn quux(x: i32)
             "#]],
         );
@@ -183,8 +187,8 @@ fn quux() {
 }
 "#,
             expect![[r#"
-                bn b      i32
-                bn a
+                lc b      i32
+                lc a
                 fn quux() fn quux()
             "#]],
         );
@@ -199,7 +203,7 @@ fn quux() {
 }
 "#,
             expect![[r#"
-                bn x
+                lc x
                 fn quux() fn quux()
             "#]],
         );
@@ -234,6 +238,24 @@ fn main() {
                 fn quux() fn quux<T>()
             "#]],
         );
+        check(
+            r#"fn quux<const C: usize>() { $0 }"#,
+            expect![[r#"
+                cp C
+                fn quux() fn quux<const C: usize>()
+            "#]],
+        );
+    }
+
+    #[test]
+    fn does_not_complete_lifetimes() {
+        mark::check!(skip_lifetime_completion);
+        check(
+            r#"fn quux<'a>() { $0 }"#,
+            expect![[r#"
+                fn quux() fn quux<'a>()
+            "#]],
+        );
     }
 
     #[test]
@@ -241,7 +263,7 @@ fn main() {
         check(
             r#"struct S<T> { x: $0}"#,
             expect![[r#"
-                tp Self
+                sp Self
                 tp T
                 st S<…>
             "#]],
@@ -253,7 +275,7 @@ fn main() {
         check(
             r#"enum X { Y($0) }"#,
             expect![[r#"
-                tp Self
+                sp Self
                 en X
             "#]],
         );
@@ -356,8 +378,8 @@ fn foo() {
 "#,
             // FIXME: should be only one bar here
             expect![[r#"
-                bn bar   i32
-                bn bar   i32
+                lc bar   i32
+                lc bar   i32
                 fn foo() fn foo()
             "#]],
         );
@@ -368,8 +390,8 @@ fn foo() {
         check(
             r#"impl S { fn foo(&self) { $0 } }"#,
             expect![[r#"
-                bn self &{unknown}
-                tp Self
+                lc self &{unknown}
+                sp Self
             "#]],
         );
     }
@@ -553,8 +575,8 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                bn y       i32
-                bn x       i32
+                lc y       i32
+                lc x       i32
                 fn quux(…) fn quux(x: i32)
                 ma m!(…)   macro_rules! m
             "#]],
@@ -572,8 +594,8 @@ fn quux(x: i32) {
 }
 ",
             expect![[r#"
-                bn y       i32
-                bn x       i32
+                lc y       i32
+                lc x       i32
                 fn quux(…) fn quux(x: i32)
                 ma m!(…)   macro_rules! m
             "#]],
@@ -591,8 +613,8 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                bn y       i32
-                bn x       i32
+                lc y       i32
+                lc x       i32
                 fn quux(…) fn quux(x: i32)
                 ma m!(…)   macro_rules! m
             "#]],
@@ -728,7 +750,7 @@ struct MyStruct {}
 impl My$0
 "#,
             expect![[r#"
-                tp Self
+                sp Self
                 tt MyTrait
                 st MyStruct
             "#]],
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
index 58fc700f3..d70ed6c1c 100644
--- a/crates/completion/src/config.rs
+++ b/crates/completion/src/config.rs
@@ -9,7 +9,7 @@ use ide_db::helpers::{insert_use::InsertUseConfig, SnippetCap};
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CompletionConfig {
     pub enable_postfix_completions: bool,
-    pub enable_autoimport_completions: bool,
+    pub enable_imports_on_the_fly: bool,
     pub add_call_parenthesis: bool,
     pub add_call_argument_snippets: bool,
     pub snippet_cap: Option<SnippetCap>,
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index 0134ff219..d2e6a6aeb 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -3,11 +3,14 @@
 use std::fmt;
 
 use hir::{Documentation, ModPath, Mutability};
-use ide_db::helpers::{
-    insert_use::{self, ImportScope, MergeBehavior},
-    mod_path_to_ast, SnippetCap,
+use ide_db::{
+    helpers::{
+        insert_use::{self, ImportScope, MergeBehavior},
+        mod_path_to_ast, SnippetCap,
+    },
+    SymbolKind,
 };
-use stdx::assert_never;
+use stdx::{assert_never, impl_from};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
 
@@ -117,49 +120,50 @@ pub enum CompletionScore {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompletionItemKind {
-    Snippet,
-    Keyword,
-    Module,
-    Function,
-    BuiltinType,
-    Struct,
-    Enum,
-    EnumVariant,
+    SymbolKind(SymbolKind),
+    Attribute,
     Binding,
-    Field,
-    Static,
-    Const,
-    Trait,
-    TypeAlias,
+    BuiltinType,
+    Keyword,
     Method,
-    TypeParam,
-    Macro,
-    Attribute,
+    Snippet,
     UnresolvedReference,
 }
 
+impl_from!(SymbolKind for CompletionItemKind);
+
 impl CompletionItemKind {
     #[cfg(test)]
     pub(crate) fn tag(&self) -> &'static str {
         match self {
+            CompletionItemKind::SymbolKind(kind) => match kind {
+                SymbolKind::Const => "ct",
+                SymbolKind::ConstParam => "cp",
+                SymbolKind::Enum => "en",
+                SymbolKind::Field => "fd",
+                SymbolKind::Function => "fn",
+                SymbolKind::Impl => "im",
+                SymbolKind::Label => "lb",
+                SymbolKind::LifetimeParam => "lt",
+                SymbolKind::Local => "lc",
+                SymbolKind::Macro => "ma",
+                SymbolKind::Module => "md",
+                SymbolKind::SelfParam => "sp",
+                SymbolKind::Static => "sc",
+                SymbolKind::Struct => "st",
+                SymbolKind::Trait => "tt",
+                SymbolKind::TypeAlias => "ta",
+                SymbolKind::TypeParam => "tp",
+                SymbolKind::Union => "un",
+                SymbolKind::ValueParam => "vp",
+                SymbolKind::Variant => "ev",
+            },
             CompletionItemKind::Attribute => "at",
             CompletionItemKind::Binding => "bn",
             CompletionItemKind::BuiltinType => "bt",
-            CompletionItemKind::Const => "ct",
-            CompletionItemKind::Enum => "en",
-            CompletionItemKind::EnumVariant => "ev",
-            CompletionItemKind::Field => "fd",
-            CompletionItemKind::Function => "fn",
             CompletionItemKind::Keyword => "kw",
-            CompletionItemKind::Macro => "ma",
             CompletionItemKind::Method => "me",
-            CompletionItemKind::Module => "md",
             CompletionItemKind::Snippet => "sn",
-            CompletionItemKind::Static => "sc",
-            CompletionItemKind::Struct => "st",
-            CompletionItemKind::Trait => "tt",
-            CompletionItemKind::TypeAlias => "ta",
-            CompletionItemKind::TypeParam => "tp",
             CompletionItemKind::UnresolvedReference => "??",
         }
     }
@@ -270,6 +274,7 @@ impl CompletionItem {
 pub struct ImportEdit {
     pub import_path: ModPath,
     pub import_scope: ImportScope,
+    pub import_for_trait_assoc_item: bool,
 }
 
 impl ImportEdit {
@@ -321,17 +326,19 @@ impl Builder {
         let mut insert_text = self.insert_text;
 
         if let Some(import_to_add) = self.import_to_add.as_ref() {
-            let mut import_path_without_last_segment = import_to_add.import_path.to_owned();
-            let _ = import_path_without_last_segment.segments.pop();
-
-            if !import_path_without_last_segment.segments.is_empty() {
-                if lookup.is_none() {
-                    lookup = Some(label.clone());
-                }
-                if insert_text.is_none() {
-                    insert_text = Some(label.clone());
+            if import_to_add.import_for_trait_assoc_item {
+                lookup = lookup.or_else(|| Some(label.clone()));
+                insert_text = insert_text.or_else(|| Some(label.clone()));
+                label = format!("{} ({})", label, import_to_add.import_path);
+            } else {
+                let mut import_path_without_last_segment = import_to_add.import_path.to_owned();
+                let _ = import_path_without_last_segment.segments.pop();
+
+                if !import_path_without_last_segment.segments.is_empty() {
+                    lookup = lookup.or_else(|| Some(label.clone()));
+                    insert_text = insert_text.or_else(|| Some(label.clone()));
+                    label = format!("{}::{}", import_path_without_last_segment, label);
                 }
-                label = format!("{}::{}", import_path_without_last_segment, label);
             }
         }
 
@@ -379,8 +386,8 @@ impl Builder {
         self.insert_text_format = InsertTextFormat::Snippet;
         self.insert_text(snippet)
     }
-    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
-        self.kind = Some(kind);
+    pub(crate) fn kind(mut self, kind: impl Into<CompletionItemKind>) -> Builder {
+        self.kind = Some(kind.into());
         self
     }
     pub(crate) fn text_edit(mut self, edit: TextEdit) -> Builder {
@@ -398,7 +405,9 @@ impl Builder {
     pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
         self.detail = detail.map(Into::into);
         if let Some(detail) = &self.detail {
-            assert_never!(detail.contains('\n'), "multiline detail: {}", detail);
+            if assert_never!(detail.contains('\n'), "multiline detail: {}", detail) {
+                self.detail = Some(detail.splitn(2, '\n').next().unwrap().to_string());
+            }
         }
         self
     }
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index ee1b822e7..2c4e54524 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -11,10 +11,10 @@ mod render;
 
 mod completions;
 
+use completions::flyimport::position_for_import;
 use ide_db::{
     base_db::FilePosition, helpers::insert_use::ImportScope, imports_locator, RootDatabase,
 };
-use syntax::AstNode;
 use text_edit::TextEdit;
 
 use crate::{completions::Completions, context::CompletionContext, item::CompletionKind};
@@ -139,12 +139,13 @@ pub fn resolve_completion_edits(
     position: FilePosition,
     full_import_path: &str,
     imported_name: String,
+    import_for_trait_assoc_item: bool,
 ) -> Option<Vec<TextEdit>> {
     let ctx = CompletionContext::new(db, position, config)?;
-    let anchor = ctx.name_ref_syntax.as_ref()?;
-    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    let position_for_import = position_for_import(&ctx, None)?;
+    let import_scope = ImportScope::find_insert_use_container(position_for_import, &ctx.sema)?;
 
-    let current_module = ctx.sema.scope(anchor.syntax()).module()?;
+    let current_module = ctx.sema.scope(position_for_import).module()?;
     let current_crate = current_module.krate();
 
     let import_path = imports_locator::find_exact_imports(&ctx.sema, current_crate, imported_name)
@@ -154,7 +155,7 @@ pub fn resolve_completion_edits(
         })
         .find(|mod_path| mod_path.to_string() == full_import_path)?;
 
-    ImportEdit { import_path, import_scope }
+    ImportEdit { import_path, import_scope, import_for_trait_assoc_item }
         .to_text_edit(config.insert_use.merge)
         .map(|edit| vec![edit])
 }
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 820dd01d1..fa594b5e5 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -10,8 +10,10 @@ pub(crate) mod type_alias;
 
 mod builder_ext;
 
-use hir::{Documentation, HasAttrs, HirDisplay, Mutability, ScopeDef, Type};
-use ide_db::{helpers::SnippetCap, RootDatabase};
+use hir::{
+    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
+};
+use ide_db::{helpers::SnippetCap, RootDatabase, SymbolKind};
 use syntax::TextRange;
 use test_utils::mark;
 
@@ -51,16 +53,16 @@ pub(crate) fn render_resolution_with_import<'a>(
     import_edit: ImportEdit,
     resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    Render::new(ctx)
-        .render_resolution(
-            import_edit.import_path.segments.last()?.to_string(),
-            Some(import_edit),
-            resolution,
-        )
-        .map(|mut item| {
-            item.completion_kind = CompletionKind::Magic;
-            item
-        })
+    let local_name = match resolution {
+        ScopeDef::ModuleDef(ModuleDef::Function(f)) => f.name(ctx.completion.db).to_string(),
+        ScopeDef::ModuleDef(ModuleDef::Const(c)) => c.name(ctx.completion.db)?.to_string(),
+        ScopeDef::ModuleDef(ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db).to_string(),
+        _ => import_edit.import_path.segments.last()?.to_string(),
+    };
+    Render::new(ctx).render_resolution(local_name, Some(import_edit), resolution).map(|mut item| {
+        item.completion_kind = CompletionKind::Magic;
+        item
+    })
 }
 
 /// Interface for data and methods required for items rendering.
@@ -87,7 +89,24 @@ impl<'a> RenderContext<'a> {
     }
 
     fn is_deprecated(&self, node: impl HasAttrs) -> bool {
-        node.attrs(self.db()).by_key("deprecated").exists()
+        let attrs = node.attrs(self.db());
+        attrs.by_key("deprecated").exists() || attrs.by_key("rustc_deprecated").exists()
+    }
+
+    fn is_deprecated_assoc_item(&self, as_assoc_item: impl AsAssocItem) -> bool {
+        let db = self.db();
+        let assoc = match as_assoc_item.as_assoc_item(db) {
+            Some(assoc) => assoc,
+            None => return false,
+        };
+
+        let is_assoc_deprecated = match assoc {
+            hir::AssocItem::Function(it) => self.is_deprecated(it),
+            hir::AssocItem::Const(it) => self.is_deprecated(it),
+            hir::AssocItem::TypeAlias(it) => self.is_deprecated(it),
+        };
+        is_assoc_deprecated
+            || assoc.containing_trait(db).map(|trait_| self.is_deprecated(trait_)).unwrap_or(false)
     }
 
     fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
@@ -127,7 +146,7 @@ impl<'a> Render<'a> {
             self.ctx.source_range(),
             name.to_string(),
         )
-        .kind(CompletionItemKind::Field)
+        .kind(SymbolKind::Field)
         .detail(ty.display(self.ctx.db()).to_string())
         .set_documentation(field.docs(self.ctx.db()))
         .set_deprecated(is_deprecated);
@@ -141,7 +160,7 @@ impl<'a> Render<'a> {
 
     fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), field.to_string())
-            .kind(CompletionItemKind::Field)
+            .kind(SymbolKind::Field)
             .detail(ty.display(self.ctx.db()).to_string())
             .build()
     }
@@ -168,7 +187,7 @@ impl<'a> Render<'a> {
                 if self.ctx.completion.is_pat_binding_or_const
                     | self.ctx.completion.is_irrefutable_pat_binding =>
             {
-                CompletionItemKind::EnumVariant
+                CompletionItemKind::SymbolKind(SymbolKind::Variant)
             }
             ScopeDef::ModuleDef(Variant(var)) => {
                 let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
@@ -179,20 +198,29 @@ impl<'a> Render<'a> {
                 return item;
             }
 
-            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
-            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct,
-            // FIXME: add CompletionItemKind::Union
-            ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct,
-            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum,
-            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
-            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
-            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
-            ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias,
+            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::SymbolKind(SymbolKind::Module),
+            ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
+                hir::Adt::Struct(_) => SymbolKind::Struct,
+                // FIXME: add CompletionItemKind::Union
+                hir::Adt::Union(_) => SymbolKind::Struct,
+                hir::Adt::Enum(_) => SymbolKind::Enum,
+            }),
+            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
+            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
+            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
+            ScopeDef::ModuleDef(TypeAlias(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::TypeAlias)
+            }
             ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
-            ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam,
-            ScopeDef::Local(..) => CompletionItemKind::Binding,
-            // (does this need its own kind?)
-            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam,
+            ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {
+                hir::GenericParam::TypeParam(_) => SymbolKind::TypeParam,
+                hir::GenericParam::LifetimeParam(_) => SymbolKind::LifetimeParam,
+                hir::GenericParam::ConstParam(_) => SymbolKind::ConstParam,
+            }),
+            ScopeDef::Local(..) => CompletionItemKind::SymbolKind(SymbolKind::Local),
+            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => {
+                CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
+            }
             ScopeDef::Unknown => {
                 let item = CompletionItem::new(
                     CompletionKind::Reference,
@@ -206,8 +234,6 @@ impl<'a> Render<'a> {
             }
         };
 
-        let docs = self.docs(resolution);
-
         let mut item =
             CompletionItem::new(completion_kind, self.ctx.source_range(), local_name.clone());
         if let ScopeDef::Local(local) = resolution {
@@ -253,13 +279,14 @@ impl<'a> Render<'a> {
             }
         }
 
-        let item = item
-            .kind(kind)
-            .add_import(import_to_add)
-            .set_documentation(docs)
-            .set_ref_match(ref_match)
-            .build();
-        Some(item)
+        Some(
+            item.kind(kind)
+                .add_import(import_to_add)
+                .set_ref_match(ref_match)
+                .set_documentation(self.docs(resolution))
+                .set_deprecated(self.is_deprecated(resolution))
+                .build(),
+        )
     }
 
     fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -275,6 +302,16 @@ impl<'a> Render<'a> {
             _ => None,
         }
     }
+
+    fn is_deprecated(&self, resolution: &ScopeDef) -> bool {
+        match resolution {
+            ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it),
+            ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it),
+            _ => false,
+        }
+    }
 }
 
 fn compute_score_from_active(
@@ -372,7 +409,9 @@ fn main() { Foo::Fo$0 }
                         source_range: 54..56,
                         delete: 54..56,
                         insert: "Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         detail: "{ x: i32, y: i32 }",
                     },
                 ]
@@ -395,7 +434,9 @@ fn main() { Foo::Fo$0 }
                         source_range: 46..48,
                         delete: 46..48,
                         insert: "Foo($0)",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         lookup: "Foo",
                         detail: "(i32, i32)",
                         trigger_call_info: true,
@@ -420,7 +461,9 @@ fn main() { Foo::Fo$0 }
                         source_range: 35..37,
                         delete: 35..37,
                         insert: "Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         detail: "()",
                     },
                 ]
@@ -444,7 +487,9 @@ fn main() { let _: m::Spam = S$0 }
                         source_range: 75..76,
                         delete: 75..76,
                         insert: "Spam::Bar($0)",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         lookup: "Spam::Bar",
                         detail: "(i32)",
                         trigger_call_info: true,
@@ -454,14 +499,18 @@ fn main() { let _: m::Spam = S$0 }
                         source_range: 75..76,
                         delete: 75..76,
                         insert: "m",
-                        kind: Module,
+                        kind: SymbolKind(
+                            Module,
+                        ),
                     },
                     CompletionItem {
                         label: "m::Spam::Foo",
                         source_range: 75..76,
                         delete: 75..76,
                         insert: "m::Spam::Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         lookup: "Spam::Foo",
                         detail: "()",
                     },
@@ -470,7 +519,9 @@ fn main() { let _: m::Spam = S$0 }
                         source_range: 75..76,
                         delete: 75..76,
                         insert: "main()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                         lookup: "main",
                         detail: "fn main()",
                     },
@@ -485,7 +536,7 @@ fn main() { let _: m::Spam = S$0 }
             r#"
 #[deprecated]
 fn something_deprecated() {}
-#[deprecated(since = "1.0.0")]
+#[rustc_deprecated(since = "1.0.0")]
 fn something_else_deprecated() {}
 
 fn main() { som$0 }
@@ -494,29 +545,35 @@ fn main() { som$0 }
                 [
                     CompletionItem {
                         label: "main()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "main()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                         lookup: "main",
                         detail: "fn main()",
                     },
                     CompletionItem {
                         label: "something_deprecated()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "something_deprecated()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                         lookup: "something_deprecated",
                         detail: "fn something_deprecated()",
                         deprecated: true,
                     },
                     CompletionItem {
                         label: "something_else_deprecated()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "something_else_deprecated()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                         lookup: "something_else_deprecated",
                         detail: "fn something_else_deprecated()",
                         deprecated: true,
@@ -537,7 +594,9 @@ fn foo() { A { the$0 } }
                         source_range: 57..60,
                         delete: 57..60,
                         insert: "the_field",
-                        kind: Field,
+                        kind: SymbolKind(
+                            Field,
+                        ),
                         detail: "u32",
                         deprecated: true,
                     },
@@ -577,7 +636,9 @@ impl S {
                         source_range: 94..94,
                         delete: 94..94,
                         insert: "foo",
-                        kind: Field,
+                        kind: SymbolKind(
+                            Field,
+                        ),
                         detail: "{unknown}",
                         documentation: Documentation(
                             "Field docs",
@@ -608,7 +669,9 @@ use self::E::*;
                         source_range: 10..12,
                         delete: 10..12,
                         insert: "E",
-                        kind: Enum,
+                        kind: SymbolKind(
+                            Enum,
+                        ),
                         documentation: Documentation(
                             "enum docs",
                         ),
@@ -618,7 +681,9 @@ use self::E::*;
                         source_range: 10..12,
                         delete: 10..12,
                         insert: "V",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                         detail: "()",
                         documentation: Documentation(
                             "variant docs",
@@ -629,7 +694,9 @@ use self::E::*;
                         source_range: 10..12,
                         delete: 10..12,
                         insert: "my",
-                        kind: Module,
+                        kind: SymbolKind(
+                            Module,
+                        ),
                         documentation: Documentation(
                             "mod docs",
                         ),
@@ -855,7 +922,7 @@ struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
 "#,
             expect![[r#"
-                bn world [type+name]
+                lc world [type+name]
                 st WorldSnapshot []
                 fn go(…) []
             "#]],
@@ -872,7 +939,7 @@ fn f(foo: &Foo) { f(foo, w$0) }
             expect![[r#"
                 st Foo []
                 fn f(…) []
-                bn foo []
+                lc foo []
             "#]],
         );
     }
diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs
index ce924f309..5010b642a 100644
--- a/crates/completion/src/render/const_.rs
+++ b/crates/completion/src/render/const_.rs
@@ -1,13 +1,14 @@
 //! Renderer for `const` fields.
 
 use hir::HasSource;
+use ide_db::SymbolKind;
 use syntax::{
     ast::{Const, NameOwner},
     display::const_label,
 };
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionKind},
     render::RenderContext,
 };
 
@@ -36,9 +37,12 @@ impl<'a> ConstRender<'a> {
         let detail = self.detail();
 
         let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
-            .kind(CompletionItemKind::Const)
+            .kind(SymbolKind::Const)
             .set_documentation(self.ctx.docs(self.const_))
-            .set_deprecated(self.ctx.is_deprecated(self.const_))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.const_)
+                    || self.ctx.is_deprecated_assoc_item(self.const_),
+            )
             .detail(detail)
             .build();
 
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 89fb49773..adcddebd1 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -1,11 +1,12 @@
 //! Renderer for `enum` variants.
 
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
+use ide_db::SymbolKind;
 use itertools::Itertools;
 use test_utils::mark;
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportEdit},
+    item::{CompletionItem, CompletionKind, ImportEdit},
     render::{builder_ext::Params, RenderContext},
 };
 
@@ -60,7 +61,7 @@ impl<'a> EnumRender<'a> {
             self.ctx.source_range(),
             self.qualified_name.clone(),
         )
-        .kind(CompletionItemKind::EnumVariant)
+        .kind(SymbolKind::Variant)
         .set_documentation(self.variant.docs(self.ctx.db()))
         .set_deprecated(self.ctx.is_deprecated(self.variant))
         .add_import(import_to_add)
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index f5b0ce3e3..2d616b1fb 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -1,6 +1,7 @@
 //! Renderer for function calls.
 
 use hir::{HasSource, Type};
+use ide_db::SymbolKind;
 use syntax::{ast::Fn, display::function_declaration};
 use test_utils::mark;
 
@@ -44,7 +45,9 @@ impl<'a> FunctionRender<'a> {
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())
             .set_documentation(self.ctx.docs(self.func))
-            .set_deprecated(self.ctx.is_deprecated(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, params)
             .add_import(import_to_add)
@@ -103,7 +106,7 @@ impl<'a> FunctionRender<'a> {
         if self.func.self_param(self.ctx.db()).is_some() {
             CompletionItemKind::Method
         } else {
-            CompletionItemKind::Function
+            SymbolKind::Function.into()
         }
     }
 }
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index f893e420a..a4535786f 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -1,11 +1,12 @@
 //! Renderer for macro invocations.
 
 use hir::{Documentation, HasSource};
+use ide_db::SymbolKind;
 use syntax::display::macro_label;
 use test_utils::mark;
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportEdit},
+    item::{CompletionItem, CompletionKind, ImportEdit},
     render::RenderContext,
 };
 
@@ -41,7 +42,7 @@ impl<'a> MacroRender<'a> {
     fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
         let mut builder =
             CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label())
-                .kind(CompletionItemKind::Macro)
+                .kind(SymbolKind::Macro)
                 .set_documentation(self.docs.clone())
                 .set_deprecated(self.ctx.is_deprecated(self.macro_))
                 .add_import(import_to_add)
diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs
index 69b445b9c..bd97c3692 100644
--- a/crates/completion/src/render/type_alias.rs
+++ b/crates/completion/src/render/type_alias.rs
@@ -1,13 +1,14 @@
 //! Renderer for type aliases.
 
 use hir::HasSource;
+use ide_db::SymbolKind;
 use syntax::{
     ast::{NameOwner, TypeAlias},
     display::type_label,
 };
 
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionKind},
     render::RenderContext,
 };
 
@@ -36,9 +37,12 @@ impl<'a> TypeAliasRender<'a> {
         let detail = self.detail();
 
         let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
-            .kind(CompletionItemKind::TypeAlias)
+            .kind(SymbolKind::TypeAlias)
             .set_documentation(self.ctx.docs(self.type_alias))
-            .set_deprecated(self.ctx.is_deprecated(self.type_alias))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.type_alias)
+                    || self.ctx.is_deprecated_assoc_item(self.type_alias),
+            )
             .detail(detail)
             .build();
 
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index 6ea6da989..baff83305 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -18,7 +18,7 @@ use crate::{item::CompletionKind, CompletionConfig, CompletionItem};
 
 pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
     enable_postfix_completions: true,
-    enable_autoimport_completions: true,
+    enable_imports_on_the_fly: true,
     add_call_parenthesis: true,
     add_call_argument_snippets: true,
     snippet_cap: SnippetCap::new(true),
@@ -83,6 +83,9 @@ pub(crate) fn completion_list_with_config(
                 let width = label_width.saturating_sub(monospace_width(it.label()));
                 format_to!(buf, "{:width$} {}", "", detail, width = width);
             }
+            if it.deprecated() {
+                format_to!(buf, " DEPRECATED");
+            }
             format_to!(buf, "\n");
             buf
         })
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 99fb65bac..9e6a3e155 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -2,6 +2,7 @@
 use hir_def::{
     attr::{Attrs, Documentation},
     path::ModPath,
+    per_ns::PerNs,
     resolver::HasResolver,
     AttrDefId, GenericParamId, ModuleDefId,
 };
@@ -112,6 +113,11 @@ fn resolve_doc_path(
     let path = ast::Path::parse(link).ok()?;
     let modpath = ModPath::from_src(path, &Hygiene::new_unhygienic()).unwrap();
     let resolved = resolver.resolve_module_path_in_items(db.upcast(), &modpath);
+    if resolved == PerNs::none() {
+        if let Some(trait_id) = resolver.resolve_module_path_in_trait_items(db.upcast(), &modpath) {
+            return Some(ModuleDefId::TraitId(trait_id));
+        };
+    }
     let def = match ns {
         Some(Namespace::Types) => resolved.take_types()?,
         Some(Namespace::Values) => resolved.take_values()?,
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 6cbf5cecf..c34a99d90 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -90,7 +90,7 @@ impl Crate {
     }
 
     pub fn root_module(self, db: &dyn HirDatabase) -> Module {
-        let module_id = db.crate_def_map(self.id).root;
+        let module_id = db.crate_def_map(self.id).root();
         Module::new(self, module_id)
     }
 
@@ -281,7 +281,7 @@ impl Module {
 
     /// Name of this module.
     pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         let parent = def_map[self.id.local_id].parent?;
         def_map[parent].children.iter().find_map(|(name, module_id)| {
             if *module_id == self.id.local_id {
@@ -302,12 +302,12 @@ impl Module {
     /// in the module tree of any target in `Cargo.toml`.
     pub fn crate_root(self, db: &dyn HirDatabase) -> Module {
         let def_map = db.crate_def_map(self.id.krate);
-        self.with_module_id(def_map.root)
+        self.with_module_id(def_map.root())
     }
 
     /// Iterates over all child modules.
     pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         let children = def_map[self.id.local_id]
             .children
             .iter()
@@ -318,7 +318,7 @@ impl Module {
 
     /// Finds a parent module.
     pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         let parent_id = def_map[self.id.local_id].parent?;
         Some(self.with_module_id(parent_id))
     }
@@ -339,7 +339,7 @@ impl Module {
         db: &dyn HirDatabase,
         visible_from: Option<Module>,
     ) -> Vec<(Name, ScopeDef)> {
-        db.crate_def_map(self.id.krate)[self.id.local_id]
+        self.id.def_map(db.upcast())[self.id.local_id]
             .scope
             .entries()
             .filter_map(|(name, def)| {
@@ -362,14 +362,14 @@ impl Module {
     }
 
     pub fn visibility_of(self, db: &dyn HirDatabase, def: &ModuleDef) -> Option<Visibility> {
-        db.crate_def_map(self.id.krate)[self.id.local_id].scope.visibility_of(def.clone().into())
+        self.id.def_map(db.upcast())[self.id.local_id].scope.visibility_of(def.clone().into())
     }
 
     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
         let _p = profile::span("Module::diagnostics").detail(|| {
             format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
         });
-        let crate_def_map = db.crate_def_map(self.id.krate);
+        let crate_def_map = self.id.def_map(db.upcast());
         crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
         for decl in self.declarations(db) {
             match decl {
@@ -396,12 +396,12 @@ impl Module {
     }
 
     pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         def_map[self.id.local_id].scope.declarations().map(ModuleDef::from).collect()
     }
 
     pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         def_map[self.id.local_id].scope.impls().map(Impl::from).collect()
     }
 
@@ -1000,7 +1000,7 @@ impl MacroDef {
     /// early, in `hir_expand`, where modules simply do not exist yet.
     pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
         let krate = self.id.krate;
-        let module_id = db.crate_def_map(krate).root;
+        let module_id = db.crate_def_map(krate).root();
         Some(Module::new(Crate { id: krate }, module_id))
     }
 
@@ -1051,6 +1051,16 @@ impl AsAssocItem for TypeAlias {
         as_assoc_item(db, AssocItem::TypeAlias, self.id)
     }
 }
+impl AsAssocItem for ModuleDef {
+    fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
+        match self {
+            ModuleDef::Function(it) => it.as_assoc_item(db),
+            ModuleDef::Const(it) => it.as_assoc_item(db),
+            ModuleDef::TypeAlias(it) => it.as_assoc_item(db),
+            _ => None,
+        }
+    }
+}
 fn as_assoc_item<ID, DEF, CTOR, AST>(db: &dyn HirDatabase, ctor: CTOR, id: ID) -> Option<AssocItem>
 where
     ID: Lookup<Data = AssocItemLoc<AST>>,
@@ -1091,6 +1101,13 @@ impl AssocItem {
             AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
         }
     }
+
+    pub fn containing_trait(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Trait(t) => Some(t),
+            _ => None,
+        }
+    }
 }
 
 impl HasVisibility for AssocItem {
@@ -2029,7 +2046,7 @@ impl Callable {
 pub enum ScopeDef {
     ModuleDef(ModuleDef),
     MacroDef(MacroDef),
-    GenericParam(TypeParam),
+    GenericParam(GenericParam),
     ImplSelfType(Impl),
     AdtSelfType(Adt),
     Local(Local),
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index d5d4cf5b6..d444f4bbb 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -1,13 +1,13 @@
 //! FIXME: write short doc here
 
 pub use hir_def::db::{
-    AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQueryQuery,
-    CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery, ExprScopesQuery,
-    FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery, InternConstQuery,
-    InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
-    InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery, InternUnionQuery,
-    ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
-    TypeAliasDataQuery, UnionDataQuery,
+    AttrsQuery, BlockDefMapQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery,
+    CrateDefMapQueryQuery, CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery,
+    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
+    InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
+    InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
+    InternUnionQuery, ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery,
+    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, HygieneFrameQuery, InternEagerExpansionQuery,
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 7c57d8378..262002671 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -24,12 +24,12 @@ pub trait HasSource {
 impl Module {
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
     pub fn definition_source(self, db: &dyn HirDatabase) -> InFile<ModuleSource> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         def_map[self.id.local_id].definition_source(db.upcast())
     }
 
     pub fn is_mod_rs(self, db: &dyn HirDatabase) -> bool {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         match def_map[self.id.local_id].origin {
             ModuleOrigin::File { is_mod_rs, .. } => is_mod_rs,
             _ => false,
@@ -39,7 +39,7 @@ impl Module {
     /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
     /// `None` for the crate root.
     pub fn declaration_source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Module>> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
         def_map[self.id.local_id].declaration_source(db.upcast())
     }
 }
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index ab213e04c..0a30b4f5b 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -814,7 +814,7 @@ impl<'a> SemanticsScope<'a> {
                 }
                 resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                 resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
-                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
+                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(id.into()),
                 resolver::ScopeDef::Local(pat_id) => {
                     let parent = resolver.body_owner().unwrap().into();
                     ScopeDef::Local(Local { parent, pat_id })
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 9bf60c72a..775f7ec8b 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -31,6 +31,7 @@ impl SourceToDefCtx<'_, '_> {
     pub(super) fn file_to_def(&mut self, file: FileId) -> Option<ModuleId> {
         let _p = profile::span("SourceBinder::to_module_def");
         let (krate, local_id) = self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+            // FIXME: inner items
             let crate_def_map = self.db.crate_def_map(crate_id);
             let local_id = crate_def_map.modules_for_file(file).next()?;
             Some((crate_id, local_id))
@@ -60,7 +61,7 @@ impl SourceToDefCtx<'_, '_> {
         }?;
 
         let child_name = src.value.name()?.as_name();
-        let def_map = self.db.crate_def_map(parent_module.krate);
+        let def_map = parent_module.def_map(self.db.upcast());
         let child_id = *def_map[parent_module.local_id].children.get(&child_name)?;
         Some(ModuleId { krate: parent_module.krate, local_id: child_id })
     }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 1b09ff816..6513daec8 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -196,7 +196,7 @@ impl Attrs {
     pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
         let raw_attrs = match def {
             AttrDefId::ModuleId(module) => {
-                let def_map = db.crate_def_map(module.krate);
+                let def_map = module.def_map(db);
                 let mod_data = &def_map[module.local_id];
                 match mod_data.declaration_source(db) {
                     Some(it) => {
@@ -207,6 +207,7 @@ impl Attrs {
                         mod_data.definition_source(db).as_ref().map(|src| match src {
                             ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
                             ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                            ModuleSource::BlockExpr(block) => block as &dyn AttrsOwner,
                         }),
                     ),
                 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 344f0b6c0..d0c84ab0b 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -29,7 +29,7 @@ use crate::{
     expr::{Expr, ExprId, Label, LabelId, Pat, PatId},
     item_scope::BuiltinShadowMode,
     item_scope::ItemScope,
-    nameres::CrateDefMap,
+    nameres::DefMap,
     path::{ModPath, Path},
     src::HasSource,
     AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
@@ -45,7 +45,7 @@ pub(crate) struct CfgExpander {
 
 pub(crate) struct Expander {
     cfg_expander: CfgExpander,
-    crate_def_map: Arc<CrateDefMap>,
+    crate_def_map: Arc<DefMap>,
     current_file_id: HirFileId,
     ast_id_map: Arc<AstIdMap>,
     module: ModuleId,
@@ -86,7 +86,7 @@ impl Expander {
         module: ModuleId,
     ) -> Expander {
         let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
-        let crate_def_map = db.crate_def_map(module.krate);
+        let crate_def_map = module.def_map(db);
         let ast_id_map = db.ast_id_map(current_file_id);
         Expander {
             cfg_expander,
@@ -122,7 +122,7 @@ impl Expander {
 
         let mut err = None;
         let call_id =
-            macro_call.as_call_id_with_errors(db, self.crate_def_map.krate, resolver, &mut |e| {
+            macro_call.as_call_id_with_errors(db, self.crate_def_map.krate(), resolver, &mut |e| {
                 err.get_or_insert(e);
             });
         let call_id = match call_id {
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index de77d5fc9..2e5d0a01e 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -6,18 +6,24 @@ use crate::{test_db::TestDB, ModuleDefId};
 use super::*;
 
 fn lower(ra_fixture: &str) -> Arc<Body> {
-    let (db, file_id) = crate::test_db::TestDB::with_single_file(ra_fixture);
+    let db = crate::test_db::TestDB::with_files(ra_fixture);
 
     let krate = db.crate_graph().iter().next().unwrap();
     let def_map = db.crate_def_map(krate);
-    let module = def_map.modules_for_file(file_id).next().unwrap();
-    let module = &def_map[module];
-    let fn_def = match module.scope.declarations().next().unwrap() {
-        ModuleDefId::FunctionId(it) => it,
-        _ => panic!(),
-    };
+    let mut fn_def = None;
+    'outer: for (_, module) in def_map.modules() {
+        for decl in module.scope.declarations() {
+            match decl {
+                ModuleDefId::FunctionId(it) => {
+                    fn_def = Some(it);
+                    break 'outer;
+                }
+                _ => {}
+            }
+        }
+    }
 
-    db.body(fn_def.into())
+    db.body(fn_def.unwrap().into())
 }
 
 fn check_diagnostics(ra_fixture: &str) {
@@ -42,6 +48,25 @@ fn main() { n_nuple!(1,2,3); }
 }
 
 #[test]
+fn macro_resolve() {
+    // Regression test for a path resolution bug introduced with inner item handling.
+    lower(
+        r"
+macro_rules! vec {
+    () => { () };
+    ($elem:expr; $n:expr) => { () };
+    ($($x:expr),+ $(,)?) => { () };
+}
+mod m {
+    fn outer() {
+        let _ = vec![FileSet::default(); self.len()];
+    }
+}
+      ",
+    );
+}
+
+#[test]
 fn cfg_diagnostics() {
     check_diagnostics(
         r"
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index dcb00a1d9..65d85c86a 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -74,7 +74,7 @@ impl ChildBySource for ImplId {
 
 impl ChildBySource for ModuleId {
     fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
-        let crate_def_map = db.crate_def_map(self.krate);
+        let crate_def_map = self.def_map(db);
         let module_data = &crate_def_map[self.local_id];
         module_data.scope.child_by_source(db)
     }
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 6ef9fe790..a87c80b8a 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,9 @@
 use std::sync::Arc;
 
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
-use hir_expand::{db::AstDatabase, HirFileId};
+use hir_expand::{db::AstDatabase, AstId, HirFileId};
 use la_arena::ArenaMap;
-use syntax::SmolStr;
+use syntax::{ast, SmolStr};
 
 use crate::{
     adt::{EnumData, StructData},
@@ -15,7 +15,7 @@ use crate::{
     import_map::ImportMap,
     item_tree::ItemTree,
     lang_item::{LangItemTarget, LangItems},
-    nameres::CrateDefMap,
+    nameres::DefMap,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
     GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
     StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
@@ -50,10 +50,13 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
 
     #[salsa::invoke(crate_def_map_wait)]
     #[salsa::transparent]
-    fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
+    fn crate_def_map(&self, krate: CrateId) -> Arc<DefMap>;
 
-    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
-    fn crate_def_map_query(&self, krate: CrateId) -> Arc<CrateDefMap>;
+    #[salsa::invoke(DefMap::crate_def_map_query)]
+    fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
+
+    #[salsa::invoke(DefMap::block_def_map_query)]
+    fn block_def_map(&self, krate: CrateId, block: AstId<ast::BlockExpr>) -> Arc<DefMap>;
 
     #[salsa::invoke(StructData::struct_data_query)]
     fn struct_data(&self, id: StructId) -> Arc<StructData>;
@@ -112,7 +115,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     fn import_map(&self, krate: CrateId) -> Arc<ImportMap>;
 }
 
-fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
+fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<DefMap> {
     let _p = profile::span("crate_def_map:wait");
     db.crate_def_map_query(krate)
 }
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 4a212d291..c01b6daf2 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -4,7 +4,7 @@ use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
 
-use crate::nameres::CrateDefMap;
+use crate::nameres::DefMap;
 use crate::{
     db::DefDatabase,
     item_scope::ItemInNs,
@@ -47,11 +47,11 @@ impl ModPath {
     }
 }
 
-fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+fn check_self_super(def_map: &DefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
     if item == ItemInNs::Types(from.into()) {
         // - if the item is the module we're in, use `self`
         Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
-    } else if let Some(parent_id) = def_map.modules[from.local_id].parent {
+    } else if let Some(parent_id) = def_map[from.local_id].parent {
         // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
         if item
             == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
@@ -110,8 +110,8 @@ fn find_path_inner(
     // Base cases:
 
     // - if the item is already in scope, return the name under which it is
-    let def_map = db.crate_def_map(from.krate);
-    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
+    let def_map = from.def_map(db);
+    let from_scope: &crate::item_scope::ItemScope = &def_map[from.local_id].scope;
     let scope_name =
         if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
     if prefixed.is_none() && scope_name.is_some() {
@@ -123,7 +123,7 @@ fn find_path_inner(
     if item
         == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
             krate: from.krate,
-            local_id: def_map.root,
+            local_id: def_map.root(),
         }))
     {
         return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
@@ -136,7 +136,7 @@ fn find_path_inner(
     }
 
     // - if the item is the crate root of a dependency crate, return the name from the extern prelude
-    for (name, def_id) in &def_map.extern_prelude {
+    for (name, def_id) in def_map.extern_prelude() {
         if item == ItemInNs::Types(*def_id) {
             let name = scope_name.unwrap_or_else(|| name.clone());
             return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
@@ -144,10 +144,10 @@ fn find_path_inner(
     }
 
     // - if the item is in the prelude, return the name from there
-    if let Some(prelude_module) = def_map.prelude {
-        let prelude_def_map = db.crate_def_map(prelude_module.krate);
+    if let Some(prelude_module) = def_map.prelude() {
+        let prelude_def_map = prelude_module.def_map(db);
         let prelude_scope: &crate::item_scope::ItemScope =
-            &prelude_def_map.modules[prelude_module.local_id].scope;
+            &prelude_def_map[prelude_module.local_id].scope;
         if let Some((name, vis)) = prelude_scope.name_of(item) {
             if vis.is_visible_from(db, from) {
                 return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
@@ -175,7 +175,7 @@ fn find_path_inner(
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
 
-    let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
+    let crate_root = ModuleId { local_id: def_map.root(), krate: from.krate };
     let crate_attrs = db.attrs(crate_root.into());
     let prefer_no_std = crate_attrs.by_key("no_std").exists();
     let mut best_path = None;
@@ -283,11 +283,11 @@ fn find_local_import_locations(
     // above `from` with any visibility. That means we do not need to descend into private siblings
     // of `from` (and similar).
 
-    let def_map = db.crate_def_map(from.krate);
+    let def_map = from.def_map(db);
 
     // Compute the initial worklist. We start with all direct child modules of `from` as well as all
     // of its (recursive) parent modules.
-    let data = &def_map.modules[from.local_id];
+    let data = &def_map[from.local_id];
     let mut worklist = data
         .children
         .values()
@@ -296,7 +296,7 @@ fn find_local_import_locations(
     let mut parent = data.parent;
     while let Some(p) = parent {
         worklist.push(ModuleId { krate: from.krate, local_id: p });
-        parent = def_map.modules[p].parent;
+        parent = def_map[p].parent;
     }
 
     let mut seen: FxHashSet<_> = FxHashSet::default();
@@ -312,7 +312,7 @@ fn find_local_import_locations(
             &def_map[module.local_id]
         } else {
             // The crate might reexport a module defined in another crate.
-            ext_def_map = db.crate_def_map(module.krate);
+            ext_def_map = module.def_map(db);
             &ext_def_map[module.local_id]
         };
 
@@ -375,7 +375,7 @@ mod tests {
             parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
         let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
 
-        let crate_def_map = db.crate_def_map(module.krate);
+        let crate_def_map = module.def_map(&db);
         let resolved = crate_def_map
             .resolve_path(
                 &db,
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index e5368b293..0b7830445 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -75,7 +75,7 @@ impl ImportMap {
 
         // We look only into modules that are public(ly reexported), starting with the crate root.
         let empty = ImportPath { segments: vec![] };
-        let root = ModuleId { krate, local_id: def_map.root };
+        let root = ModuleId { krate, local_id: def_map.root() };
         let mut worklist = vec![(root, empty)];
         while let Some((module, mod_path)) = worklist.pop() {
             let ext_def_map;
@@ -83,7 +83,7 @@ impl ImportMap {
                 &def_map[module.local_id]
             } else {
                 // The crate might reexport a module defined in another crate.
-                ext_def_map = db.crate_def_map(module.krate);
+                ext_def_map = module.def_map(db);
                 &ext_def_map[module.local_id]
             };
 
@@ -263,6 +263,7 @@ pub enum ImportKind {
     Trait,
     TypeAlias,
     BuiltinType,
+    AssociatedItem,
 }
 
 /// A way to match import map contents against the search query.
@@ -282,6 +283,7 @@ pub struct Query {
     query: String,
     lowercased: String,
     name_only: bool,
+    assoc_items_only: bool,
     search_mode: SearchMode,
     case_sensitive: bool,
     limit: usize,
@@ -295,6 +297,7 @@ impl Query {
             query,
             lowercased,
             name_only: false,
+            assoc_items_only: false,
             search_mode: SearchMode::Contains,
             case_sensitive: false,
             limit: usize::max_value(),
@@ -309,6 +312,11 @@ impl Query {
         Self { name_only: true, ..self }
     }
 
+    /// Matches only the entries that are associated items, ignoring the rest.
+    pub fn assoc_items_only(self) -> Self {
+        Self { assoc_items_only: true, ..self }
+    }
+
     /// Specifies the way to search for the entries using the query.
     pub fn search_mode(self, search_mode: SearchMode) -> Self {
         Self { search_mode, ..self }
@@ -331,6 +339,14 @@ impl Query {
     }
 
     fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {
+        if import.is_trait_assoc_item {
+            if self.exclude_import_kinds.contains(&ImportKind::AssociatedItem) {
+                return false;
+            }
+        } else if self.assoc_items_only {
+            return false;
+        }
+
         let mut input = if import.is_trait_assoc_item || self.name_only {
             import.path.segments.last().unwrap().to_string()
         } else {
@@ -814,6 +830,56 @@ mod tests {
     }
 
     #[test]
+    fn assoc_items_filtering() {
+        let ra_fixture = r#"
+        //- /main.rs crate:main deps:dep
+        //- /dep.rs crate:dep
+        pub mod fmt {
+            pub trait Display {
+                type FmtTypeAlias;
+                const FMT_CONST: bool;
+
+                fn format_function();
+                fn format_method(&self);
+            }
+        }
+    "#;
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).search_mode(SearchMode::Fuzzy).assoc_items_only(),
+            expect![[r#"
+            dep::fmt::Display::FMT_CONST (a)
+            dep::fmt::Display::format_function (a)
+            dep::fmt::Display::format_method (a)
+        "#]],
+        );
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string())
+                .search_mode(SearchMode::Fuzzy)
+                .exclude_import_kind(ImportKind::AssociatedItem),
+            expect![[r#"
+            dep::fmt (t)
+            dep::fmt::Display (t)
+        "#]],
+        );
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string())
+                .search_mode(SearchMode::Fuzzy)
+                .assoc_items_only()
+                .exclude_import_kind(ImportKind::AssociatedItem),
+            expect![[r#""#]],
+        );
+    }
+
+    #[test]
     fn search_mode() {
         let ra_fixture = r#"
             //- /main.rs crate:main deps:dep
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 9a433b61c..b8d7608e7 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -21,6 +21,7 @@ use hir_expand::{
     HirFileId, InFile,
 };
 use la_arena::{Arena, Idx, RawIdx};
+use profile::Count;
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
 use syntax::{ast, match_ast};
@@ -67,15 +68,16 @@ impl GenericParamsId {
 /// The item tree of a source file.
 #[derive(Debug, Eq, PartialEq)]
 pub struct ItemTree {
+    _c: Count<Self>,
+
     top_level: SmallVec<[ModItem; 1]>,
     attrs: FxHashMap<AttrOwner, RawAttrs>,
-    inner_items: FxHashMap<FileAstId<ast::Item>, SmallVec<[ModItem; 1]>>,
 
     data: Option<Box<ItemTreeData>>,
 }
 
 impl ItemTree {
-    pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+    pub