81 files changed, 1821 insertions, 908 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index ece1fd364..a97ed24ba 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -118,6 +118,37 @@ jobs:
        name: dist-x86_64-unknown-linux-gnu
        path: ./dist
+  dist-aarch64-unknown-linux-gnu:
+    name: dist (aarch64-unknown-linux-gnu)
+    runs-on: ubuntu-16.04
+    env:
+      RA_TARGET: aarch64-unknown-linux-gnu
+      CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        target: aarch64-unknown-linux-gnu
+        profile: minimal
+        override: true
+    - name: Install target toolchain
+      run: sudo apt-get install gcc-aarch64-linux-gnu
+    - name: Dist
+      run: cargo xtask dist
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: dist-aarch64-unknown-linux-gnu
+        path: ./dist
  dist-x86_64-apple-darwin:
    name: dist (x86_64-apple-darwin)
    runs-on: macos-latest
@@ -174,7 +205,7 @@ jobs:
  publish:
    name: publish
    runs-on: ubuntu-16.04
-    needs: ['dist-x86_64-pc-windows-msvc', 'dist-aarch64-pc-windows-msvc', 'dist-x86_64-unknown-linux-gnu', 'dist-x86_64-apple-darwin', 'dist-aarch64-apple-darwin']
+    needs: ['dist-x86_64-pc-windows-msvc', 'dist-aarch64-pc-windows-msvc', 'dist-x86_64-unknown-linux-gnu', 'dist-aarch64-unknown-linux-gnu', 'dist-x86_64-apple-darwin', 'dist-aarch64-apple-darwin']
    steps:
    - name: Install Nodejs
      uses: actions/setup-node@v1
@@ -207,6 +238,10 @@ jobs:
        path: dist
    - uses: actions/download-artifact@v1
      with:
+        name: dist-aarch64-unknown-linux-gnu
+        path: dist
+    - uses: actions/download-artifact@v1
+      with:
        name: dist-x86_64-pc-windows-msvc
        path: dist
    - uses: actions/download-artifact@v1
diff --git a/Cargo.lock b/Cargo.lock
index dd1d599e3..f01544324 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,9 +26,9 @@ dependencies = [
 [[package]]
 name = "anyhow"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee67c11feeac938fae061b232e38e0b6d94f97a9df10e6271319325ac4c56a86"
+checksum = "afddf7f520a80dbf76e6f50a35bca42a2331ef227a28b3b6dc5c2e2338d114b1"
 [[package]]
 name = "anymap"
@@ -118,9 +118,9 @@ checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
 [[package]]
 name = "byteorder"
-version = "1.3.4"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b"
 [[package]]
 name = "cargo-platform"
@@ -133,9 +133,9 @@ dependencies = [
 [[package]]
 name = "cargo_metadata"
-version = "0.12.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11a47b6286279a9998588ef7050d1ebc2500c69892a557c90fe5d071c64415dc"
+checksum = "7714a157da7991e23d90686b9524b9e12e0407a108647f52e9328f4b3d51ac7f"
 dependencies = [
 "cargo-platform",
 "semver",
@@ -269,9 +269,9 @@ dependencies = [
 [[package]]
 name = "const_fn"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd51eab21ab4fd6a3bf889e2d0958c0a6e3a61ad04260325e919e652a2a62826"
+checksum = "28b9d6de7f49e22cf97ad17fc4036ece69300032f45f78f30b4a4482cdc3f4a6"
 [[package]]
 name = "crc32fast"
@@ -449,6 +449,12 @@ dependencies = [
 ]
 [[package]]
+name = "fs_extra"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2022715d62ab30faffd124d40b76f4134a550a87792276512b18d63272333394"
+[[package]]
 name = "fsevent"
 version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -502,6 +508,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
 [[package]]
+name = "hashbrown"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2140e9c963869f01789fa4fef4805211081ec794af5fc77c0d5b377906118853"
+[[package]]
 name = "heck"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -512,9 +524,9 @@ dependencies = [
 [[package]]
 name = "hermit-abi"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
 dependencies = [
 "libc",
 ]
@@ -686,7 +698,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
 dependencies = [
 "autocfg",
- "hashbrown",
+ "hashbrown 0.9.1",
 ]
 [[package]]
@@ -702,9 +714,9 @@ dependencies = [
 [[package]]
 name = "inotify-sys"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4563555856585ab3180a5bf0b2f9f8d301a728462afffc8195b3f5394229c55"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
 dependencies = [
 "libc",
 ]
@@ -752,6 +764,38 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
 [[package]]
+name = "jemalloc-ctl"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c502a5ff9dd2924f1ed32ba96e3b65735d837b4bfd978d3161b1702e66aca4b7"
+dependencies = [
+ "jemalloc-sys",
+ "libc",
+ "paste",
+]
+[[package]]
+name = "jemalloc-sys"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d3b9f3f5c9b31aa0f5ed3260385ac205db665baa41d49bb8338008ae94ede45"
+dependencies = [
+ "cc",
+ "fs_extra",
+ "libc",
+]
+[[package]]
+name = "jemallocator"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43ae63fcfc45e99ab3d1b29a46782ad679e98436c3169d15a167a1108a724b69"
+dependencies = [
+ "jemalloc-sys",
+ "libc",
+]
+[[package]]
 name = "jod-thread"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -785,15 +829,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 [[package]]
 name = "libc"
-version = "0.2.81"
+version = "0.2.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"
+checksum = "89203f3fba0a3795506acaad8ebce3c80c0af93f994d5a1d7a0b1eeb23271929"
 [[package]]
 name = "libloading"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9367bdfa836b7e3cf895867f7a570283444da90562980ec2263d6e1569b16bc"
+checksum = "351a32417a12d5f7e82c368a66781e307834dae04c6ce0cd4456d52989229883"
 dependencies = [
 "cfg-if 1.0.0",
 "winapi 0.3.9",
@@ -819,9 +863,9 @@ dependencies = [
 [[package]]
 name = "log"
-version = "0.4.11"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
+checksum = "fcf3805d4480bb5b86070dcfeb9e2cb2ebc148adb753c5cca5f884d1d65a42b2"
 dependencies = [
 "cfg-if 0.1.10",
 ]
@@ -1099,6 +1143,25 @@ dependencies = [
 ]
 [[package]]
+name = "paste"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880"
+dependencies = [
+ "paste-impl",
+ "proc-macro-hack",
+]
+[[package]]
+name = "paste-impl"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6"
+dependencies = [
+ "proc-macro-hack",
+]
+[[package]]
 name = "paths"
 version = "0.0.0"
@@ -1154,9 +1217,15 @@ checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
 [[package]]
 name = "pin-project-lite"
-version = "0.2.0"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b063f57ec186e6140e2b8b6921e5f1bd89c7356dda5b33acc5401203ca6131c"
+checksum = "439697af366c49a6d0a010c56a0d97685bc140ce0d377b13a2ea2aa42d64a827"
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
 [[package]]
 name = "proc-macro2"
@@ -1206,6 +1275,7 @@ name = "profile"
 version = "0.0.0"
 dependencies = [
 "cfg-if 1.0.0",
+ "jemalloc-ctl",
 "la-arena",
 "libc",
 "once_cell",
@@ -1225,6 +1295,7 @@ dependencies = [
 "log",
 "paths",
 "proc_macro_api",
+ "profile",
 "rustc-hash",
 "serde",
 "serde_json",
@@ -1294,9 +1365,9 @@ checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 [[package]]
 name = "regex"
-version = "1.4.2"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c"
+checksum = "d9251239e129e16308e70d853559389de218ac275b515068abc96829d05b948a"
 dependencies = [
 "regex-syntax",
 ]
@@ -1313,16 +1384,17 @@ dependencies = [
 [[package]]
 name = "regex-syntax"
-version = "0.6.21"
+version = "0.6.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
+checksum = "b5eb417147ba9860a96cfe72a0b93bf88fee1744b5636ec99ab20c1aa9376581"
 [[package]]
 name = "rowan"
-version = "0.10.3"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d55d358c5fda3d5c4484f71a4808f5eeb39a0aff93bf3acebc680a6d15376f3c"
+checksum = "e1898adeafc7d3c69913b33ee1acbbb39c726a9dbe05ff77c08b52957643e8db"
 dependencies = [
+ "hashbrown 0.10.0",
 "rustc-hash",
 "smol_str",
 "text-size",
@@ -1346,6 +1418,7 @@ dependencies = [
 "ide",
 "ide_db",
 "itertools 0.10.0",
+ "jemallocator",
 "jod-thread",
 "log",
 "lsp-server",
@@ -1477,18 +1550,18 @@ dependencies = [
 [[package]]
 name = "serde"
-version = "1.0.118"
+version = "1.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800"
+checksum = "9bdd36f49e35b61d49efd8aa7fc068fd295961fd2286d0b2ee9a4c7a14e99cc3"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.118"
+version = "1.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df"
+checksum = "552954ce79a059ddd5fd68c271592374bd15cab2274970380c000118aeffe1cd"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1544,9 +1617,9 @@ checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
 [[package]]
 name = "smallvec"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a55ca5f3b68e41c979bf8c46a6f1da892ca4db8f94023ce0bd32407573b1ac0"
+checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
 [[package]]
 name = "smol_str"
@@ -1586,9 +1659,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.57"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4211ce9909eb971f111059df92c45640aad50a619cf55cd76476be803c4c68e6"
+checksum = "cc60a3d73ea6594cd712d830cc1f0390fd71542d8c8cd24e70cc54cdfd5e05d5"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1665,9 +1738,9 @@ dependencies = [
 [[package]]
 name = "thread_local"
-version = "1.0.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
+checksum = "bb9bc092d0d51e76b2b19d9d85534ffc9ec2db959a2523cdae0697e2972cd447"
 dependencies = [
 "lazy_static",
 ]
@@ -1831,9 +1904,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 [[package]]
 name = "ungrammar"
-version = "1.8.0"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33a2183403af89252547c4219a06a6cc8aef6302fee67e10e8431866af3ee72"
+checksum = "f5901372c0f3a6a1a9d880aef134c8eaf5e54409343637508c0a344270b42d7b"
 [[package]]
 name = "unicase"
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 =
+    let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
-        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
+    let proposed_imports =
-            ImportAssets::for_regular_path(path_under_caret, &ctx.sema)
+        import_assets.search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind);
-        } 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);
    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 =
+    let scope = ImportScope::find_insert_use_container(&syntax_under_caret, &ctx.sema)?;
-        ImportScope::find_insert_use_container(import_assets.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/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..af8a11d03 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::{
+use ide_db::helpers::{import_assets::ImportCandidate, mod_path_to_ast};
-    import_assets::{ImportAssets, 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 =
+    let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
-        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_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> {
+fn item_as_trait(db: &RootDatabase, item: hir::ItemInNs) -> Option<hir::Trait> {
-    if let hir::ModuleDef::Trait(trait_) = hir::ModuleDef::from(item.as_module_def_id()?) {
+    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/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index 222809638..47e797ac8 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 ide_db::helpers::{
-use syntax::AstNode;
+    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();
+    let potential_import_name = {
-    if potential_import_name.len() < 2 {
+        let token_kind = ctx.token.kind();
-        return None;
+        if matches!(token_kind, T![.] | T![::]) {
-    }
+            String::new()
-    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.to_string());
+        } else {
+            ctx.token.to_string()
+        }
+    };
-    let current_module = ctx.scope.module()?;
+    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.to_string());
-    let anchor = ctx.name_ref_syntax.as_ref()?;
-    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
    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),
+    let mut all_mod_paths = import_assets
-        potential_import_name,
+        .search_for_relative_paths(&ctx.sema)
-        true,
+        .into_iter()
-        true,
+        .map(|(mod_path, item_in_ns)| {
-    )
+            let scope_item = match item_in_ns {
-    .filter_map(|import_candidate| {
+                hir::ItemInNs::Types(id) => ScopeDef::ModuleDef(id.into()),
-        Some(match import_candidate {
+                hir::ItemInNs::Values(id) => ScopeDef::ModuleDef(id.into()),
-            Either::Left(module_def) => {
+                hir::ItemInNs::Macros(id) => ScopeDef::MacroDef(id.into()),
-                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
+            };
-            }
+            (mod_path, scope_item)
-            Either::Right(macro_def) => {
-                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
-            }
        })
-    })
+        .collect::<Vec<_>>();
-    .filter(|(mod_path, _)| mod_path.len() > 1)
-    .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(
+        let import_for_trait_assoc_item = match definition {
-            RenderContext::new(ctx),
+            ScopeDef::ModuleDef(module_def) => module_def
-            ImportEdit { import_path, import_scope: import_scope.clone() },
+                .as_assoc_item(ctx.db)
-            &definition,
+                .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,129 @@ 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_assoc_item_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() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.$0
+}
+        "#,
+            expect![[r#"
+                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self)
+                "#]],
+        );
+        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::$0
+}
+"#,
+            expect![[r#"
+                ct SPECIAL_CONST (dep::test_mod::TestTrait)
+                fn weird_function() (dep::test_mod::TestTrait) fn weird_function()
+        "#]],
+        );
+    }
 }
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..4147853e7 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -270,6 +270,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 +322,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();
+            if import_to_add.import_for_trait_assoc_item {
-            let _ = import_path_without_last_segment.segments.pop();
+                lookup = lookup.or_else(|| Some(label.clone()));
+                insert_text = insert_text.or_else(|| Some(label.clone()));
-            if !import_path_without_last_segment.segments.is_empty() {
+                label = format!("{} ({})", label, import_to_add.import_path);
-                if lookup.is_none() {
+            } else {
-                    lookup = Some(label.clone());
+                let mut import_path_without_last_segment = import_to_add.import_path.to_owned();
-                }
+                let _ = import_path_without_last_segment.segments.pop();
-                if insert_text.is_none() {
-                    insert_text = Some(label.clone());
+                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);
            }
        }
@@ -398,7 +401,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 position_for_import = position_for_import(&ctx, None)?;
-    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    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..4b3c9702a 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -10,7 +10,7 @@ pub(crate) mod type_alias;
 mod builder_ext;
-use hir::{Documentation, HasAttrs, HirDisplay, Mutability, ScopeDef, Type};
+use hir::{Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type};
 use ide_db::{helpers::SnippetCap, RootDatabase};
 use syntax::TextRange;
 use test_utils::mark;
@@ -51,16 +51,16 @@ pub(crate) fn render_resolution_with_import<'a>(
    import_edit: ImportEdit,
    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    Render::new(ctx)
+    let local_name = match resolution {
-        .render_resolution(
+        ScopeDef::ModuleDef(ModuleDef::Function(f)) => f.name(ctx.completion.db).to_string(),
-            import_edit.import_path.segments.last()?.to_string(),
+        ScopeDef::ModuleDef(ModuleDef::Const(c)) => c.name(ctx.completion.db)?.to_string(),
-            Some(import_edit),
+        ScopeDef::ModuleDef(ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db).to_string(),
-            resolution,
+        _ => import_edit.import_path.segments.last()?.to_string(),
-        )
+    };
-        .map(|mut item| {
+    Render::new(ctx).render_resolution(local_name, Some(import_edit), resolution).map(|mut item| {
-            item.completion_kind = CompletionKind::Magic;
+        item.completion_kind = CompletionKind::Magic;
-            item
+        item
-        })
+    })
 }
 /// Interface for data and methods required for items rendering.
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index 6ea6da989..3faf861b9 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),
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 6cbf5cecf..2950f08b8 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -272,6 +272,15 @@ impl ModuleDef {
        hir_ty::diagnostics::validate_module_item(db, module.id.krate, id, sink)
    }
+    pub fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
+        match self {
+            ModuleDef::Function(f) => f.as_assoc_item(db),
+            ModuleDef::Const(c) => c.as_assoc_item(db),
+            ModuleDef::TypeAlias(t) => t.as_assoc_item(db),
+            _ => None,
+        }
+    }
 }
 impl Module {
@@ -1091,6 +1100,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 {
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index e5368b293..fac0de90c 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -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..ff62928df 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -145,7 +145,6 @@ impl ItemTree {
                macro_calls,
                macro_rules,
                macro_defs,
-                exprs,
                vis,
                generics,
            } = &mut **data;
@@ -167,7 +166,6 @@ impl ItemTree {
            macro_calls.shrink_to_fit();
            macro_rules.shrink_to_fit();
            macro_defs.shrink_to_fit();
-            exprs.shrink_to_fit();
            vis.arena.shrink_to_fit();
            generics.arena.shrink_to_fit();
@@ -296,7 +294,6 @@ struct ItemTreeData {
    macro_calls: Arena<MacroCall>,
    macro_rules: Arena<MacroRules>,
    macro_defs: Arena<MacroDef>,
-    exprs: Arena<Expr>,
    vis: ItemVisibilities,
    generics: GenericParamsStorage,
@@ -461,7 +458,7 @@ macro_rules! impl_index {
    };
 }
-impl_index!(fields: Field, variants: Variant, exprs: Expr);
+impl_index!(fields: Field, variants: Variant);
 impl Index<RawVisibilityId> for ItemTree {
    type Output = RawVisibility;
@@ -664,11 +661,6 @@ pub struct MacroDef {
    pub ast_id: FileAstId<ast::MacroDef>,
 }
-// NB: There's no `FileAstId` for `Expr`. The only case where this would be useful is for array
-// lengths, but we don't do much with them yet.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Expr;
 macro_rules! impl_froms {
    ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
        $(
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 3dd7c3cbb..e34cd7f2f 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -87,7 +87,7 @@ impl ModPath {
    /// If this path is a single identifier, like `foo`, return its name.
    pub fn as_ident(&self) -> Option<&Name> {
-        if self.kind != PathKind::Plain || self.segments.len() > 1 {
+        if !self.is_ident() {
            return None;
        }
        self.segments.first()
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index ae93d0d10..049b2e462 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -159,6 +159,8 @@ impl TypeRef {
            ast::Type::DynTraitType(inner) => {
                TypeRef::DynTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
            }
+            // FIXME: Macros in type position are not yet supported.
+            ast::Type::MacroType(_) => TypeRef::Error,
        }
    }
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 8db581b77..c8ea81210 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -76,6 +76,8 @@ pub struct HygieneFrame {
 impl HygieneFrames {
    fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Self {
+        // Note that this intentionally avoids the `hygiene_frame` query to avoid blowing up memory
+        // usage. The query is only helpful for nested `HygieneFrame`s as it avoids redundant work.
        HygieneFrames(Arc::new(HygieneFrame::new(db, file_id)))
    }
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 1923daca5..75e950816 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -135,7 +135,6 @@ mod tests {
        let result = format!("{:#?}", remove_derive_attrs(&tt).unwrap());
        assert_eq_text!(
-            &result,
            r#"
 SUBTREE $
  PUNCH   # [alone] 0
@@ -150,7 +149,8 @@ SUBTREE $
    PUNCH   : [alone] 19
    IDENT   u32 20
 "#
-            .trim()
+            .trim(),
+            &result
        );
    }
 }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 3b1675f0b..5ff755321 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -26,7 +26,7 @@ use once_cell::race::OnceBool;
 use stdx::format_to;
 use syntax::{
    algo,
-    ast::{self, AstNode},
+    ast::{self, AstNode, NameOwner},
    SyntaxNode,
 };
 use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry};
@@ -153,7 +153,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
        });
        for (node, ty) in &types {
            let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.value.clone()) {
-                (self_param.self_token().unwrap().text_range(), "self".to_string())
+                (self_param.name().unwrap().syntax().text_range(), "self".to_string())
            } else {
                (node.value.text_range(), node.value.text().to_string().replace("\n", " "))
            };
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index e4335119b..579d5a308 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -140,7 +140,7 @@ impl DiagnosticWithFix for IncorrectCase {
            rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
        let label = format!("Rename to {}", self.suggested_text);
-        Some(Fix::new(&label, rename_changes.info, rename_changes.range))
+        Some(Fix::new(&label, rename_changes, frange.range))
    }
 }
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 685052e7f..00e601244 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -400,15 +400,13 @@ impl TryToNav for hir::GenericParam {
 impl ToNav for hir::Local {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
-        let (node, focus_range) = match &src.value {
+        let (node, name) = match &src.value {
-            Either::Left(bind_pat) => (
+            Either::Left(bind_pat) => (bind_pat.syntax().clone(), bind_pat.name()),
-                bind_pat.syntax().clone(),
+            Either::Right(it) => (it.syntax().clone(), it.name()),
-                bind_pat
-                    .name()
-                    .map(|it| src.with_value(&it.syntax().clone()).original_file_range(db).range),
-            ),
-            Either::Right(it) => (it.syntax().clone(), it.self_token().map(|it| it.text_range())),
        };
+        let focus_range =
+            name.map(|it| src.with_value(&it.syntax().clone()).original_file_range(db).range);
        let full_range = src.with_value(&node).original_file_range(db);
        let name = match self.name(db) {
            Some(it) => it.to_string().into(),
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index de10406bc..1f08d7810 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -438,10 +438,10 @@ fn get_symbol_fragment(db: &dyn HirDatabase, field_or_assoc: &FieldOrAssocItem)
        FieldOrAssocItem::Field(field) => format!("#structfield.{}", field.name(db)),
        FieldOrAssocItem::AssocItem(assoc) => match assoc {
            AssocItem::Function(function) => {
-                let is_trait_method = matches!(
+                let is_trait_method = function
-                    function.as_assoc_item(db).map(|assoc| assoc.container(db)),
+                    .as_assoc_item(db)
-                    Some(AssocItemContainer::Trait(..))
+                    .and_then(|assoc| assoc.containing_trait(db))
-                );
+                    .is_some();
                // This distinction may get more complicated when specialization is available.
                // Rustdoc makes this decision based on whether a method 'has defaultness'.
                // Currently this is only the case for provided trait methods.
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 988a5668f..a1d2bce1d 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -55,11 +55,6 @@ pub(crate) fn goto_definition(
            } else {
                reference_definition(&sema, Either::Left(&lt)).to_vec()
            },
-            ast::SelfParam(self_param) => {
-                let def = NameClass::classify_self_param(&sema, &self_param)?.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
-                vec![nav]
-            },
            _ => return None,
        }
    };
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 6022bd275..2024acd94 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -98,7 +98,6 @@ pub(crate) fn hover(
            ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
            ast::Lifetime(lifetime) => NameClass::classify_lifetime(&sema, &lifetime)
                .map_or_else(|| NameRefClass::classify_lifetime(&sema, &lifetime).map(|d| d.referenced(sema.db)), |d| d.defined(sema.db)),
-            ast::SelfParam(self_param) => NameClass::classify_self_param(&sema, &self_param).and_then(|d| d.defined(sema.db)),
            _ => None,
        }
    };
@@ -3223,7 +3222,7 @@ impl Foo {
 }
 "#,
            expect![[r#"
-                *&self*
+                *self*
                ```rust
                &Foo
@@ -3243,7 +3242,7 @@ impl Foo {
 }
 "#,
            expect![[r#"
-                *self: Arc<Foo>*
+                *self*
                ```rust
                Arc<Foo>
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index f8d69382e..3abbb14c6 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -86,18 +86,15 @@ pub use completion::{
    InsertTextFormat,
 };
 pub use hir::{Documentation, Semantics};
-pub use ide_db::base_db::{
-    Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
-    SourceRootId,
-};
 pub use ide_db::{
+    base_db::{
+        Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange,
+        SourceRoot, SourceRootId,
+    },
    call_info::CallInfo,
-    search::{FileReference, ReferenceAccess, ReferenceKind},
-};
-pub use ide_db::{
    label::Label,
    line_index::{LineCol, LineIndex},
-    search::SearchScope,
+    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope},
    source_change::{FileSystemEdit, SourceChange},
    symbol_index::Query,
    RootDatabase,
@@ -481,6 +478,7 @@ impl Analysis {
        position: FilePosition,
        full_import_path: &str,
        imported_name: String,
+        import_for_trait_assoc_item: bool,
    ) -> Cancelable<Vec<TextEdit>> {
        Ok(self
            .with_db(|db| {
@@ -490,6 +488,7 @@ impl Analysis {
                    position,
                    full_import_path,
                    imported_name,
+                    import_for_trait_assoc_item,
                )
            })?
            .unwrap_or_default())
@@ -523,7 +522,7 @@ impl Analysis {
        &self,
        position: FilePosition,
        new_name: &str,
-    ) -> Cancelable<Result<RangeInfo<SourceChange>, RenameError>> {
+    ) -> Cancelable<Result<SourceChange, RenameError>> {
        self.with_db(|db| references::rename::rename(db, position, new_name))
    }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 51a2f4327..df9c31aef 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -930,6 +930,26 @@ impl Foo {
        );
    }
+    #[test]
+    fn test_find_self_refs_decl() {
+        check(
+            r#"
+struct Foo { bar: i32 }
+impl Foo {
+    fn foo(self$0) {
+        self;
+    }
+}
+"#,
+            expect![[r#"
+                self SelfParam FileId(0) 47..51 47..51 SelfParam
+                FileId(0) 63..67 Other Read
+            "#]],
+        );
+    }
    fn check(ra_fixture: &str, expect: Expect) {
        check_with_scope(ra_fixture, None, expect)
    }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 9ac4af026..c25bcce50 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,27 +1,25 @@
 //! FIXME: write short doc here
-use std::{
+use std::fmt::{self, Display};
-    convert::TryInto,
-    fmt::{self, Display},
-};
-use hir::{Module, ModuleDef, ModuleSource, Semantics};
+use either::Either;
+use hir::{HasSource, InFile, Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::{
-    base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt},
+    base_db::{AnchoredPathBuf, FileId, FileRange},
    defs::{Definition, NameClass, NameRefClass},
    search::FileReference,
    RootDatabase,
 };
+use stdx::assert_never;
 use syntax::{
-    algo::find_node_at_offset,
    ast::{self, NameOwner},
-    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken, T,
+    lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
 use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
+    display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, SourceChange,
-    TextRange, TextSize,
+    TextRange,
 };
 type RenameResult<T> = Result<T, RenameError>;
@@ -50,24 +48,22 @@ pub(crate) fn prepare_rename(
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
+    let range = match &find_name_like(&sema, &syntax, position)
-        rename_mod(&sema, position, module, "dummy")
+        .ok_or_else(|| format_err!("No references found at position"))?
-    } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
    {
-        rename_self_to_param(&sema, position, self_token, "dummy")
+        NameLike::Name(it) => it.syntax(),
-    } else {
+        NameLike::NameRef(it) => it.syntax(),
-        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
+        NameLike::Lifetime(it) => it.syntax(),
-        Ok(RangeInfo::new(range, SourceChange::default()))
    }
-    .map(|info| RangeInfo::new(info.range, ()))
+    .text_range();
+    Ok(RangeInfo::new(range, ()))
 }
 pub(crate) fn rename(
    db: &RootDatabase,
    position: FilePosition,
    new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
    let sema = Semantics::new(db);
    rename_with_semantics(&sema, position, new_name)
 }
@@ -76,18 +72,15 @@ pub(crate) fn rename_with_semantics(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
+    let def = find_definition(sema, syntax, position)
-        rename_mod(&sema, position, module, new_name)
+        .ok_or_else(|| format_err!("No references found at position"))?;
-    } else if let Some(self_token) =
+    match def {
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
+        Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
-    {
+        def => rename_reference(sema, def, new_name),
-        rename_self_to_param(&sema, position, self_token, new_name)
-    } else {
-        rename_reference(&sema, position, new_name)
    }
 }
@@ -98,17 +91,12 @@ pub(crate) fn will_rename_file(
 ) -> Option<SourceChange> {
    let sema = Semantics::new(db);
    let module = sema.to_module_def(file_id)?;
+    let mut change = rename_mod(&sema, module, new_name_stem).ok()?;
-    let decl = module.declaration_source(db)?;
-    let range = decl.value.name()?.syntax().text_range();
-    let position = FilePosition { file_id: decl.file_id.original_file(db), offset: range.start() };
-    let mut change = rename_mod(&sema, position, module, new_name_stem).ok()?.info;
    change.file_system_edits.clear();
    Some(change)
 }
-#[derive(Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum IdentifierKind {
    Ident,
    Lifetime,
@@ -135,40 +123,51 @@ fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
    }
 }
-fn find_module_at_offset(
+enum NameLike {
+    Name(ast::Name),
+    NameRef(ast::NameRef),
+    Lifetime(ast::Lifetime),
+}
+fn find_name_like(
    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
    syntax: &SyntaxNode,
-) -> Option<Module> {
+    position: FilePosition,
-    let ident = syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::IDENT)?;
+) -> Option<NameLike> {
+    let namelike = if let Some(name_ref) =
-    let module = match_ast! {
+        sema.find_node_at_offset_with_descend::<ast::NameRef>(syntax, position.offset)
-        match (ident.parent()) {
+    {
-            ast::NameRef(name_ref) => {
+        NameLike::NameRef(name_ref)
-                match NameRefClass::classify(sema, &name_ref)? {
+    } else if let Some(name) =
-                    NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+        sema.find_node_at_offset_with_descend::<ast::Name>(syntax, position.offset)
-                    _ => return None,
+    {
-                }
+        NameLike::Name(name)
-            },
+    } else if let Some(lifetime) =
-            ast::Name(name) => {
+        sema.find_node_at_offset_with_descend::<ast::Lifetime>(syntax, position.offset)
-                match NameClass::classify(&sema, &name)? {
+    {
-                    NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+        NameLike::Lifetime(lifetime)
-                    _ => return None,
+    } else {
-                }
+        return None;
-            },
-            _ => return None,
-        }
    };
+    Some(namelike)
-    Some(module)
 }
-fn find_all_refs(
+fn find_definition(
    sema: &Semantics<RootDatabase>,
+    syntax: &SyntaxNode,
    position: FilePosition,
-) -> RenameResult<RangeInfo<ReferenceSearchResult>> {
+) -> Option<Definition> {
-    crate::references::find_all_refs(sema, position, None)
+    let def = match find_name_like(sema, syntax, position)? {
-        .ok_or_else(|| format_err!("No references found at position"))
+        NameLike::Name(name) => NameClass::classify(sema, &name)?.referenced_or_defined(sema.db),
+        NameLike::NameRef(name_ref) => NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
+        NameLike::Lifetime(lifetime) => NameRefClass::classify_lifetime(sema, &lifetime)
+            .map(|class| NameRefClass::referenced(class, sema.db))
+            .or_else(|| {
+                NameClass::classify_lifetime(sema, &lifetime)
+                    .map(|it| it.referenced_or_defined(sema.db))
+            })?,
+    };
+    Some(def)
 }
 fn source_edit_from_references(
@@ -242,72 +241,84 @@ fn edit_text_range_for_record_field_expr_or_pat(
 fn rename_mod(
    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
    module: Module,
    new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
    if IdentifierKind::Ident != check_identifier(new_name)? {
        bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
    }
    let mut source_change = SourceChange::default();
-    let src = module.definition_source(sema.db);
+    let InFile { file_id, value: def_source } = module.definition_source(sema.db);
-    let file_id = src.file_id.original_file(sema.db);
+    let file_id = file_id.original_file(sema.db);
-    match src.value {
+    if let ModuleSource::SourceFile(..) = def_source {
-        ModuleSource::SourceFile(..) => {
+        // mod is defined in path/to/dir/mod.rs
-            // mod is defined in path/to/dir/mod.rs
+        let path = if module.is_mod_rs(sema.db) {
-            let path = if module.is_mod_rs(sema.db) {
+            format!("../{}/mod.rs", new_name)
-                format!("../{}/mod.rs", new_name)
+        } else {
-            } else {
+            format!("{}.rs", new_name)
-                format!("{}.rs", new_name)
+        };
-            };
+        let dst = AnchoredPathBuf { anchor: file_id, path };
-            let dst = AnchoredPathBuf { anchor: file_id, path };
+        let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
-            let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
+        source_change.push_file_system_edit(move_file);
-            source_change.push_file_system_edit(move_file);
+    }
-        }
-        ModuleSource::Module(..) => {}
+    if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
-    }
+        let file_id = file_id.original_file(sema.db);
+        match decl_source.name() {
-    if let Some(src) = module.declaration_source(sema.db) {
+            Some(name) => source_change.insert_source_edit(
-        let file_id = src.file_id.original_file(sema.db);
+                file_id,
-        let name = src.value.name().unwrap();
+                TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
-        source_change.insert_source_edit(
+            ),
-            file_id,
+            _ => unreachable!(),
-            TextEdit::replace(name.syntax().text_range(), new_name.into()),
+        };
-        );
    }
+    let def = Definition::ModuleDef(ModuleDef::Module(module));
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
+    let usages = def.usages(sema).all();
-    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
+    let ref_edits = usages.iter().map(|(&file_id, references)| {
        source_edit_from_references(sema, file_id, references, new_name)
    });
    source_change.extend(ref_edits);
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
-fn rename_to_self(
+fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
-    sema: &Semantics<RootDatabase>,
+    if assert_never!(local.is_self(sema.db)) {
-    position: FilePosition,
+        bail!("rename_to_self invoked on self");
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+    }
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
+    let fn_def = match local.parent(sema.db) {
+        hir::DefWithBody::Function(func) => func,
+        _ => bail!("Cannot rename non-param local to self"),
+    };
+    // FIXME: reimplement this on the hir instead
+    // as of the time of this writing params in hir don't keep their names
+    let fn_ast =
+        fn_def.source(sema.db).ok_or(format_err!("Cannot rename non-param local to self"))?.value;
-    let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
+    let first_param_range = fn_ast
-        .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-    let param_range = fn_ast
        .param_list()
        .and_then(|p| p.params().next())
        .ok_or_else(|| format_err!("Method has no parameters"))?
        .syntax()
        .text_range();
-    if !param_range.contains(position.offset) {
+    let InFile { file_id, value: local_source } = local.source(sema.db);
-        bail!("Only the first parameter can be self");
+    match local_source {
+        either::Either::Left(pat)
+            if !first_param_range.contains_range(pat.syntax().text_range()) =>
+        {
+            bail!("Only the first parameter can be self");
+        }
+        _ => (),
    }
-    let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
+    let impl_block = fn_ast
+        .syntax()
+        .ancestors()
+        .find_map(|node| ast::Impl::cast(node))
        .and_then(|def| sema.to_def(&def))
        .ok_or_else(|| format_err!("No impl block found for function"))?;
    if fn_def.self_param(sema.db).is_some() {
@@ -331,25 +342,21 @@ fn rename_to_self(
        bail!("Parameter type differs from impl block type");
    }
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
    let mut source_change = SourceChange::default();
-    source_change.extend(refs.references().iter().map(|(&file_id, references)| {
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
        source_edit_from_references(sema, file_id, references, "self")
    }));
    source_change.insert_source_edit(
-        position.file_id,
+        file_id.original_file(sema.db),
-        TextEdit::replace(param_range, String::from(self_param)),
+        TextEdit::replace(first_param_range, String::from(self_param)),
    );
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
-fn text_edit_from_self_param(
+fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
-    syn: &SyntaxNode,
-    self_param: &ast::SelfParam,
-    new_name: &str,
-) -> Option<TextEdit> {
    fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
        if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
            return Some(p.path()?.segment()?.name_ref()?.text().to_string());
@@ -357,7 +364,7 @@ fn text_edit_from_self_param(
        None
    }
-    let impl_def = find_node_at_offset::<ast::Impl>(syn, self_param.syntax().text_range().start())?;
+    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
    let type_name = target_type_name(&impl_def)?;
    let mut replacement_text = String::from(new_name);
@@ -374,96 +381,119 @@ fn text_edit_from_self_param(
 fn rename_self_to_param(
    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
+    local: hir::Local,
-    self_token: SyntaxToken,
    new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+    identifier_kind: IdentifierKind,
-    let ident_kind = check_identifier(new_name)?;
+) -> RenameResult<SourceChange> {
-    match ident_kind {
+    let (file_id, self_param) = match local.source(sema.db) {
-        IdentifierKind::Lifetime => bail!("Invalid name `{}`: not an identifier", new_name),
+        InFile { file_id, value: Either::Right(self_param) } => (file_id, self_param),
-        IdentifierKind::ToSelf => {
+        _ => {
-            // no-op
+            assert_never!(true, "rename_self_to_param invoked on a non-self local");
-            mark::hit!(rename_self_to_self);
+            bail!("rename_self_to_param invoked on a non-self local");
-            return Ok(RangeInfo::new(self_token.text_range(), SourceChange::default()));
-        }
-        _ => (),
-    }
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
-    let text = sema.db.file_text(position.file_id);
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-    let search_range = fn_def.syntax().text_range();
-    let mut source_change = SourceChange::default();
-    for (idx, _) in text.match_indices("self") {
-        let offset: TextSize = idx.try_into().unwrap();
-        if !search_range.contains_inclusive(offset) {
-            continue;
        }
-        if let Some(ref usage) = syn.token_at_offset(offset).find(|t| t.kind() == T![self]) {
+    };
-            let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
-                text_edit_from_self_param(syn, self_param, new_name)
-                    .ok_or_else(|| format_err!("No target type found"))?
-            } else {
-                TextEdit::replace(usage.text_range(), String::from(new_name))
-            };
-            source_change.insert_source_edit(position.file_id, edit);
-        }
-    }
-    if source_change.source_file_edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
+    let edit = text_edit_from_self_param(&self_param, new_name)
+        .ok_or_else(|| format_err!("No target type found"))?;
+    if usages.len() > 1 && identifier_kind == IdentifierKind::Underscore {
        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
    }
+    let mut source_change = SourceChange::default();
-    let range = ast::SelfParam::cast(self_token.parent())
+    source_change.insert_source_edit(file_id.original_file(sema.db), edit);
-        .map_or(self_token.text_range(), |p| p.syntax().text_range());
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, &references, new_name)
-    Ok(RangeInfo::new(range, source_change))
+    }));
+    Ok(source_change)
 }
 fn rename_reference(
    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
+    def: Definition,
    new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<SourceChange> {
    let ident_kind = check_identifier(new_name)?;
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-    match (ident_kind, &refs.declaration.kind) {
+    let def_is_lbl_or_lt = matches!(def,
-        (IdentifierKind::ToSelf, ReferenceKind::Lifetime)
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_))
-        | (IdentifierKind::Underscore, ReferenceKind::Lifetime)
+        | Definition::Label(_)
-        | (IdentifierKind::Ident, ReferenceKind::Lifetime) => {
+    );
+    match (ident_kind, def) {
+        (IdentifierKind::ToSelf, _)
+        | (IdentifierKind::Underscore, _)
+        | (IdentifierKind::Ident, _)
+            if def_is_lbl_or_lt =>
+        {
            mark::hit!(rename_not_a_lifetime_ident_ref);
            bail!("Invalid name `{}`: not a lifetime identifier", new_name)
        }
-        (IdentifierKind::Lifetime, ReferenceKind::Lifetime) => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
        (IdentifierKind::Lifetime, _) => {
            mark::hit!(rename_not_an_ident_ref);
            bail!("Invalid name `{}`: not an identifier", new_name)
        }
-        (IdentifierKind::ToSelf, ReferenceKind::SelfParam) => {
+        (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
-            unreachable!("rename_self_to_param should've been called instead")
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(SourceChange::default());
        }
-        (IdentifierKind::ToSelf, _) => {
+        (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
-            mark::hit!(rename_to_self);
+            mark::hit!(rename_self_to_param);
-            return rename_to_self(sema, position);
+            return rename_self_to_param(sema, local, new_name, ident_kind);
        }
-        (IdentifierKind::Underscore, _) if !refs.references.is_empty() => {
+        (IdentifierKind::ToSelf, Definition::Local(local)) => {
-            mark::hit!(rename_underscore_multiple);
+            mark::hit!(rename_to_self);
-            bail!("Cannot rename reference to `_` as it is being referenced multiple times")
+            return rename_to_self(sema, local);
        }
+        (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
    }
+    let usages = def.usages(sema).all();
+    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
+        mark::hit!(rename_underscore_multiple);
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
    let mut source_change = SourceChange::default();
-    source_change.extend(refs.into_iter().map(|(file_id, references)| {
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
        source_edit_from_references(sema, file_id, &references, new_name)
    }));
-    Ok(RangeInfo::new(range, source_change))
+    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
+    source_change.insert_source_edit(file_id, edit);
+    Ok(source_change)
+}
+fn source_edit_from_def(
+    sema: &Semantics<RootDatabase>,
+    def: Definition,
+    new_name: &str,
+) -> RenameResult<(FileId, TextEdit)> {
+    let nav = def.try_to_nav(sema.db).unwrap();
+    let mut replacement_text = String::new();
+    let mut repl_range = nav.focus_or_full_range();
+    if let Definition::Local(local) = def {
+        if let Either::Left(pat) = local.source(sema.db).value {
+            if matches!(
+                pat.syntax().parent().and_then(ast::RecordPatField::cast),
+                Some(pat_field) if pat_field.name_ref().is_none()
+            ) {
+                replacement_text.push_str(": ");
+                replacement_text.push_str(new_name);
+                repl_range = TextRange::new(
+                    pat.syntax().text_range().end(),
+                    pat.syntax().text_range().end(),
+                );
+            }
+        }
+    }
+    if replacement_text.is_empty() {
+        replacement_text.push_str(new_name);
+    }
+    let edit = TextEdit::replace(repl_range, replacement_text);
+    Ok((nav.file_id, edit))
 }
 #[cfg(test)]
@@ -485,7 +515,7 @@ mod tests {
            Ok(source_change) => {
                let mut text_edit_builder = TextEdit::builder();
                let mut file_id: Option<FileId> = None;
-                for edit in source_change.info.source_file_edits {
+                for edit in source_change.source_file_edits {
                    file_id = Some(edit.0);
                    for indel in edit.1.into_iter() {
                        text_edit_builder.replace(indel.delete, indel.insert);
@@ -884,36 +914,33 @@ mod foo$0;
 // empty
 "#,
            expect![[r#"
-                RangeInfo {
+                SourceChange {
-                    range: 4..7,
+                    source_file_edits: {
-                    info: SourceChange {
+                        FileId(
-                        source_file_edits: {
+                            1,
-                            FileId(
+                        ): TextEdit {
-                                1,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "foo2",
-                                    Indel {
+                                    delete: 4..7,
-                                        insert: "foo2",
+                                },
-                                        delete: 4..7,
+                            ],
-                                    },
-                                ],
-                            },
                        },
-                        file_system_edits: [
+                    },
-                            MoveFile {
+                    file_system_edits: [
-                                src: FileId(
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                    2,
                                ),
-                                dst: AnchoredPathBuf {
+                                path: "foo2.rs",
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
                            },
-                        ],
+                        },
-                        is_snippet: false,
+                    ],
-                    },
+                    is_snippet: false,
                }
            "#]],
        );
@@ -936,46 +963,43 @@ pub struct FooContent;
 use crate::foo$0::FooContent;
 "#,
            expect![[r#"
-                RangeInfo {
+                SourceChange {
-                    range: 11..14,
+                    source_file_edits: {
-                    info: SourceChange {
+                        FileId(
-                        source_file_edits: {
+                            0,
-                            FileId(
+                        ): TextEdit {
-                                0,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "quux",
-                                    Indel {
+                                    delete: 8..11,
-                                        insert: "quux",
+                                },
-                                        delete: 8..11,
+                            ],
-                                    },
+                        },
-                                ],
+                        FileId(
-                            },
+                            2,
-                            FileId(
+                        ): TextEdit {
-                                2,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "quux",
-                                    Indel {
+                                    delete: 11..14,
-                                        insert: "quux",
+                                },
-                                        delete: 11..14,
+                            ],
-                                    },
-                                ],
-                            },
                        },
-                        file_system_edits: [
+                    },
-                            MoveFile {
+                    file_system_edits: [
-                                src: FileId(
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                    1,
                                ),
-                                dst: AnchoredPathBuf {
+                                path: "quux.rs",
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "quux.rs",
-                                },
                            },
-                        ],
+                        },
-                        is_snippet: false,
+                    ],
-                    },
+                    is_snippet: false,
                }
            "#]],
        );
@@ -992,36 +1016,33 @@ mod fo$0o;
 // empty
 "#,
            expect![[r#"
-                RangeInfo {
+                SourceChange {
-                    range: 4..7,
+                    source_file_edits: {
-                    info: SourceChange {
+                        FileId(
-                        source_file_edits: {
+                            0,
-                            FileId(
+                        ): TextEdit {
-                                0,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "foo2",
-                                    Indel {
+                                    delete: 4..7,
-                                        insert: "foo2",
+                                },
-                                        delete: 4..7,
+                            ],
-                                    },
-                                ],
-                            },
                        },
-                        file_system_edits: [
+                    },
-                            MoveFile {
+                    file_system_edits: [
-                                src: FileId(
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                    1,
                                ),
-                                dst: AnchoredPathBuf {
+                                path: "../foo2/mod.rs",
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "../foo2/mod.rs",
-                                },
                            },
-                        ],
+                        },
-                        is_snippet: false,
+                    ],
-                    },
+                    is_snippet: false,
                }
            "#]],
        );
@@ -1039,36 +1060,33 @@ mod outer { mod fo$0o; }
 // empty
 "#,
            expect![[r#"
-                RangeInfo {
+                SourceChange {
-                    range: 16..19,
+                    source_file_edits: {
-                    info: SourceChange {
+                        FileId(
-                        source_file_edits: {
+                            0,
-                            FileId(
+                        ): TextEdit {
-                                0,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "bar",
-                                    Indel {
+                                    delete: 16..19,
-                                        insert: "bar",
+                                },
-                                        delete: 16..19,
+                            ],
-                                    },
-                                ],
-                            },
                        },
-                        file_system_edits: [
+                    },
-                            MoveFile {
+                    file_system_edits: [
-                                src: FileId(
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                    1,
                                ),
-                                dst: AnchoredPathBuf {
+                                path: "bar.rs",
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "bar.rs",
-                                },
                            },
-                        ],
+                        },
-                        is_snippet: false,
+                    ],
-                    },
+                    is_snippet: false,
                }
            "#]],
        );
@@ -1109,46 +1127,43 @@ pub mod foo$0;
 // pub fn fun() {}
 "#,
            expect![[r#"
-                RangeInfo {
+                SourceChange {
-                    range: 8..11,
+                    source_file_edits: {
-                    info: SourceChange {
+                        FileId(
-                        source_file_edits: {
+                            0,
-                            FileId(
+                        ): TextEdit {
-                                0,
+                            indels: [
-                            ): TextEdit {
+                                Indel {
-                                indels: [
+                                    insert: "foo2",
-                                    Indel {
+                                    delete: 27..30,
-                                        insert: "foo2",
+                                },
-                                        delete: 27..30,
+                            ],
-                                    },
-                                ],
-                            },
-                            FileId(
-                                1,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 8..11,
-                                    },
-                                ],
-                            },
                        },
-                        file_system_edits: [
+                        FileId(
-                            MoveFile {
+                            1,
-                                src: FileId(
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 8..11,
+                                },
+                            ],
+                        },
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                    2,
                                ),
-                                dst: AnchoredPathBuf {
+                                path: "foo2.rs",
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
                            },
-                        ],
+                        },
-                        is_snippet: false,
+                    ],
-                    },
+                    is_snippet: false,
                }
            "#]],
        );
@@ -1350,6 +1365,7 @@ impl Foo {
    #[test]
    fn test_owned_self_to_parameter() {
+        mark::check!(rename_self_to_param);
        check(
            "foo",
            r#"
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 87578e70a..8625ef5df 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -68,7 +68,8 @@ pub(super) fn element(
        NAME_REF => {
            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
            highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
-                match NameRefClass::classify(sema, &name_ref) {
+                let is_self = name_ref.self_token().is_some();
+                let h = match NameRefClass::classify(sema, &name_ref) {
                    Some(name_kind) => match name_kind {
                        NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
                        NameRefClass::Definition(def) => {
@@ -108,6 +109,11 @@ pub(super) fn element(
                        highlight_name_ref_by_syntax(name_ref, sema)
                    }
                    None => HlTag::UnresolvedReference.into(),
+                };
+                if h.tag == HlTag::Symbol(SymbolKind::Module) && is_self {
+                    HlTag::Symbol(SymbolKind::SelfParam).into()
+                } else {
+                    h
                }
            })
        }
@@ -225,18 +231,8 @@ pub(super) fn element(
                T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
                T![unsafe] => h | HlMod::Unsafe,
                T![true] | T![false] => HlTag::BoolLiteral.into(),
-                T![self] => {
+                // self is handled as either a Name or NameRef already
-                    let self_param = element.parent().and_then(ast::SelfParam::cast);
+                T![self] => return None,
-                    if let Some(NameClass::Definition(def)) = self_param
-                        .and_then(|self_param| NameClass::classify_self_param(sema, &self_param))
-                    {
-                        highlight_def(db, def) | HlMod::Definition
-                    } else if element.ancestors().any(|it| it.kind() == USE_TREE) {
-                        HlTag::Symbol(SymbolKind::SelfParam).into()
-                    } else {
-                        return None;
-                    }
-                }
                T![ref] => element
                    .parent()
                    .and_then(ast::IdentPat::cast)
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index 1d4bac7ad..4c63d3023 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -111,7 +111,6 @@ mod tests {
        let syn = analysis.syntax_tree(file_id, None).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -127,7 +126,8 @@ [email protected]
      [email protected] "{"
      [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
        let (analysis, file_id) = fixture::file(
@@ -143,7 +143,6 @@ fn test() {
        let syn = analysis.syntax_tree(file_id, None).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -176,7 +175,8 @@ [email protected]
      [email protected] "\n"
      [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
    }
@@ -186,7 +186,6 @@ [email protected]
        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected] "fn"
@@ -201,7 +200,8 @@ [email protected]
    [email protected] "{"
    [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
        let (analysis, range) = fixture::range(
@@ -216,7 +216,6 @@ [email protected]
        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -234,7 +233,8 @@ [email protected]
      [email protected] ")"
  [email protected] ";"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
    }
@@ -253,7 +253,6 @@ fn bar() {
        );
        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -270,7 +269,8 @@ [email protected]
      [email protected] "\n"
      [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
        // With a raw string
@@ -287,7 +287,6 @@ fn bar() {
        );
        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -304,7 +303,8 @@ [email protected]
      [email protected] "\n"
      [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
        // With a raw string
@@ -320,7 +320,6 @@ fn bar() {
        );
        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
        assert_eq_text!(
-            syn.trim(),
            r#"
 [email protected]
  [email protected]
@@ -351,7 +350,8 @@ [email protected]
      [email protected] "\n"
      [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
        );
    }
 }
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 231e886a9..d9875ffef 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -117,13 +117,6 @@ impl NameClass {
        }
    }
-    pub fn classify_self_param(
-        sema: &Semantics<RootDatabase>,
-        self_param: &ast::SelfParam,
-    ) -> Option<NameClass> {
-        sema.to_def(self_param).map(Definition::Local).map(NameClass::Definition)
-    }
    pub fn classify(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameClass> {
        let _p = profile::span("classify_name");
@@ -186,6 +179,10 @@ impl NameClass {
                    Some(NameClass::Definition(Definition::Local(local)))
                },
+                ast::SelfParam(it) => {
+                    let def = sema.to_def(&it)?;
+                    Some(NameClass::Definition(Definition::Local(def.into())))
+                },
                ast::RecordField(it) => {
                    let field: hir::Field = sema.to_def(&it)?;
                    Some(NameClass::Definition(Definition::Field(field)))
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index edc3da318..517abbb4b 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -1,12 +1,13 @@
 //! Look up accessible paths for items.
 use either::Either;
-use hir::{AsAssocItem, AssocItemContainer, ModuleDef, Semantics};
+use hir::{AsAssocItem, AssocItem, Crate, MacroDef, Module, ModuleDef, PrefixKind, Semantics};
 use rustc_hash::FxHashSet;
-use syntax::{ast, AstNode, SyntaxNode};
+use syntax::{ast, AstNode};
-use crate::{imports_locator, RootDatabase};
+use crate::{
+    imports_locator::{self, AssocItemSearch, DEFAULT_QUERY_SEARCH_LIMIT},
-use super::insert_use::InsertUseConfig;
+    RootDatabase,
+};
 #[derive(Debug)]
 pub enum ImportCandidate {
@@ -24,86 +25,141 @@ pub enum ImportCandidate {
 #[derive(Debug)]
 pub struct TraitImportCandidate {
-    pub ty: hir::Type,
+    pub receiver_ty: hir::Type,
-    pub name: ast::NameRef,
+    pub name: NameToImport,
 }
 #[derive(Debug)]
 pub struct PathImportCandidate {
    pub qualifier: Option<ast::Path>,
-    pub name: ast::NameRef,
+    pub name: NameToImport,
+}
+#[derive(Debug)]
+pub enum NameToImport {
+    Exact(String),
+    Fuzzy(String),
+}
+impl NameToImport {
+    pub fn text(&self) -> &str {
+        match self {
+            NameToImport::Exact(text) => text.as_str(),
+            NameToImport::Fuzzy(text) => text.as_str(),
+        }
+    }
 }
 #[derive(Debug)]
 pub struct ImportAssets {
    import_candidate: ImportCandidate,
-    module_with_name_to_import: hir::Module,
+    module_with_candidate: hir::Module,
-    syntax_under_caret: SyntaxNode,
 }
 impl ImportAssets {
    pub fn for_method_call(
-        method_call: ast::MethodCallExpr,
+        method_call: &ast::MethodCallExpr,
        sema: &Semantics<RootDatabase>,
    ) -> Option<Self> {
-        let syntax_under_caret = method_call.syntax().to_owned();
-        let module_with_name_to_import = sema.scope(&syntax_under_caret).module()?;
        Some(Self {
-            import_candidate: ImportCandidate::for_method_call(sema, &method_call)?,
+            import_candidate: ImportCandidate::for_method_call(sema, method_call)?,
-            module_with_name_to_import,
+            module_with_candidate: sema.scope(method_call.syntax()).module()?,
-            syntax_under_caret,
        })
    }
-    pub fn for_regular_path(
+    pub fn for_exact_path(
-        path_under_caret: ast::Path,
+        fully_qualified_path: &ast::Path,
        sema: &Semantics<RootDatabase>,
    ) -> Option<Self> {
-        let syntax_under_caret = path_under_caret.syntax().to_owned();
+        let syntax_under_caret = fully_qualified_path.syntax();
        if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
            return None;
        }
-        let module_with_name_to_import = sema.scope(&syntax_under_caret).module()?;
        Some(Self {
-            import_candidate: ImportCandidate::for_regular_path(sema, &path_under_caret)?,
+            import_candidate: ImportCandidate::for_regular_path(sema, fully_qualified_path)?,
-            module_with_name_to_import,
+            module_with_candidate: sema.scope(syntax_under_caret).module()?,
-            syntax_under_caret,
        })
    }
-    pub fn syntax_under_caret(&self) -> &SyntaxNode {
+    pub fn for_fuzzy_path(
-        &self.syntax_under_caret
+        module_with_path: Module,
+        qualifier: Option<ast::Path>,
+        fuzzy_name: String,
+        sema: &Semantics<RootDatabase>,
+    ) -> Option<Self> {
+        Some(match qualifier {
+            Some(qualifier) => {
+                let qualifier_resolution = sema.resolve_path(&qualifier)?;
+                match qualifier_resolution {
+                    hir::PathResolution::Def(hir::ModuleDef::Adt(assoc_item_path)) => Self {
+                        import_candidate: ImportCandidate::TraitAssocItem(TraitImportCandidate {
+                            receiver_ty: assoc_item_path.ty(sema.db),
+                            name: NameToImport::Fuzzy(fuzzy_name),
+                        }),
+                        module_with_candidate: module_with_path,
+                    },
+                    _ => Self {
+                        import_candidate: ImportCandidate::Path(PathImportCandidate {
+                            qualifier: Some(qualifier),
+                            name: NameToImport::Fuzzy(fuzzy_name),
+                        }),
+                        module_with_candidate: module_with_path,
+                    },
+                }
+            }
+            None => Self {
+                import_candidate: ImportCandidate::Path(PathImportCandidate {
+                    qualifier: None,
+                    name: NameToImport::Fuzzy(fuzzy_name),
+                }),
+                module_with_candidate: module_with_path,
+            },
+        })
    }
+    pub fn for_fuzzy_method_call(
+        module_with_method_call: Module,
+        receiver_ty: hir::Type,
+        fuzzy_method_name: String,
+    ) -> Option<Self> {
+        Some(Self {
+            import_candidate: ImportCandidate::TraitMethod(TraitImportCandidate {
+                receiver_ty,
+                name: NameToImport::Fuzzy(fuzzy_method_name),
+            }),
+            module_with_candidate: module_with_method_call,
+        })
+    }
+}
+impl ImportAssets {
    pub fn import_candidate(&self) -> &ImportCandidate {
        &self.import_candidate
    }
-    fn get_search_query(&self) -> &str {
+    fn name_to_import(&self) -> &NameToImport {
        match &self.import_candidate {
-            ImportCandidate::Path(candidate) => candidate.name.text(),
+            ImportCandidate::Path(candidate) => &candidate.name,
            ImportCandidate::TraitAssocItem(candidate)
-            | ImportCandidate::TraitMethod(candidate) => candidate.name.text(),
+            | ImportCandidate::TraitMethod(candidate) => &candidate.name,
        }
    }
    pub fn search_for_imports(
        &self,
        sema: &Semantics<RootDatabase>,
-        config: &InsertUseConfig,
+        prefix_kind: PrefixKind,
    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
-        let _p = profile::span("import_assists::search_for_imports");
+        let _p = profile::span("import_assets::search_for_imports");
-        self.search_for(sema, Some(config.prefix_kind))
+        self.search_for(sema, Some(prefix_kind))
    }
    /// This may return non-absolute paths if a part of the returned path is already imported into scope.
-    #[allow(dead_code)]
    pub fn search_for_relative_paths(
        &self,
        sema: &Semantics<RootDatabase>,
    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
-        let _p = profile::span("import_assists::search_for_relative_paths");
+        let _p = profile::span("import_assets::search_for_relative_paths");
        self.search_for(sema, None)
    }
@@ -112,99 +168,142 @@ impl ImportAssets {
        sema: &Semantics<RootDatabase>,
        prefixed: Option<hir::PrefixKind>,
    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
-        let db = sema.db;
+        let current_crate = self.module_with_candidate.krate();
-        let mut trait_candidates = FxHashSet::default();
-        let current_crate = self.module_with_name_to_import.krate();
-        let filter = |candidate: Either<hir::ModuleDef, hir::MacroDef>| {
+        let unfiltered_imports = match self.name_to_import() {
-            trait_candidates.clear();
+            NameToImport::Exact(exact_name) => {
-            match &self.import_candidate {
+                imports_locator::find_exact_imports(sema, current_crate, exact_name.clone())
-                ImportCandidate::TraitAssocItem(trait_candidate) => {
+            }
-                    let located_assoc_item = match candidate {
+            // FIXME: ideally, we should avoid using `fst` for seacrhing trait imports for assoc items:
-                        Either::Left(ModuleDef::Function(located_function)) => {
+            // instead, we need to look up all trait impls for a certain struct and search through them only
-                            located_function.as_assoc_item(db)
+            // see https://github.com/rust-analyzer/rust-analyzer/pull/7293#issuecomment-761585032
-                        }
+            // and https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Fwg-rls-2.2E0/topic/Blanket.20trait.20impls.20lookup
-                        Either::Left(ModuleDef::Const(located_const)) => {
+            // for the details
-                            located_const.as_assoc_item(db)
+            NameToImport::Fuzzy(fuzzy_name) => {
-                        }
+                let (assoc_item_search, limit) = match self.import_candidate {
-                        _ => None,
+                    ImportCandidate::TraitAssocItem(_) | ImportCandidate::TraitMethod(_) => {
+                        (AssocItemSearch::AssocItemsOnly, None)
                    }
-                    .map(|assoc| assoc.container(db))
+                    _ => (AssocItemSearch::Exclude, Some(DEFAULT_QUERY_SEARCH_LIMIT)),
-                    .and_then(Self::assoc_to_trait)?;
+                };
+                imports_locator::find_similar_imports(
-                    trait_candidates.insert(located_assoc_item.into());
+                    sema,
+                    current_crate,
+                    fuzzy_name.clone(),
+                    assoc_item_search,
+                    limit,
+                )
+            }
+        };
-                    trait_candidate
+        let db = sema.db;
-                        .ty
+        let mut res =
-                        .iterate_path_candidates(
+            applicable_defs(self.import_candidate(), current_crate, db, unfiltered_imports)
-                            db,
+                .filter_map(|candidate| {
-                            current_crate,
+                    let item: hir::ItemInNs = candidate.clone().either(Into::into, Into::into);
-                            &trait_candidates,
-                            None,
-                            |_, assoc| Self::assoc_to_trait(assoc.container(db)),
-                        )
-                        .map(ModuleDef::from)
-                        .map(Either::Left)
-                }
-                ImportCandidate::TraitMethod(trait_candidate) => {
-                    let located_assoc_item =
-                        if let Either::Left(ModuleDef::Function(located_function)) = candidate {
-                            located_function
-                                .as_assoc_item(db)
-                                .map(|assoc| assoc.container(db))
-                                .and_then(Self::assoc_to_trait)
-                        } else {
-                            None
-                        }?;
-                    trait_candidates.insert(located_assoc_item.into());
+                    let item_to_search = match self.import_candidate {
+                        ImportCandidate::TraitAssocItem(_) | ImportCandidate::TraitMethod(_) => {
+                            let canidate_trait = match candidate {
+                                Either::Left(module_def) => {
+                                    module_def.as_assoc_item(db)?.containing_trait(db)
+                                }
+                                _ => None,
+                            }?;
+                            ModuleDef::from(canidate_trait).into()
+                        }
+                        _ => item,
+                    };
-                    trait_candidate
+                    if let Some(prefix_kind) = prefixed {
-                        .ty
+                        self.module_with_candidate.find_use_path_prefixed(
-                        .iterate_method_candidates(
                            db,
-                            current_crate,
+                            item_to_search,
-                            &trait_candidates,
+                            prefix_kind,
-                            None,
-                            |_, function| {
-                                Self::assoc_to_trait(function.as_assoc_item(db)?.container(db))
-                            },
                        )
-                        .map(ModuleDef::from)
+                    } else {
-                        .map(Either::Left)
+                        self.module_with_candidate.find_use_path(db, item_to_search)
-                }
+                    }
-                _ => Some(candidate),
+                    .map(|path| (path, item))
-            }
+                })
-        };
+                .filter(|(use_path, _)| use_path.len() > 1)
+                .collect::<Vec<_>>();
-        let mut res = imports_locator::find_exact_imports(
+        res.sort_by_cached_key(|(path, _)| path.clone());
-            sema,
-            current_crate,
-            self.get_search_query().to_string(),
-        )
-        .filter_map(filter)
-        .filter_map(|candidate| {
-            let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
-            if let Some(prefix_kind) = prefixed {
-                self.module_with_name_to_import.find_use_path_prefixed(db, item, prefix_kind)
-            } else {
-                self.module_with_name_to_import.find_use_path(db, item)
-            }
-            .map(|path| (path, item))
-        })
-        .filter(|(use_path, _)| use_path.len() > 1)
-        .take(20)
-        .collect::<Vec<_>>();
-        res.sort_by_key(|(path, _)| path.clone());
        res
    }
+}
-    fn assoc_to_trait(assoc: AssocItemContainer) -> Option<hir::Trait> {
+fn applicable_defs<'a>(
-        if let AssocItemContainer::Trait(extracted_trait) = assoc {
+    import_candidate: &ImportCandidate,
-            Some(extracted_trait)
+    current_crate: Crate,
-        } else {
+    db: &RootDatabase,
-            None
+    unfiltered_imports: Box<dyn Iterator<Item = Either<ModuleDef, MacroDef>> + 'a>,
+) -> Box<dyn Iterator<Item = Either<ModuleDef, MacroDef>> + 'a> {
+    let receiver_ty = match import_candidate {
+        ImportCandidate::Path(_) => return unfiltered_imports,
+        ImportCandidate::TraitAssocItem(candidate) | ImportCandidate::TraitMethod(candidate) => {
+            &candidate.receiver_ty
        }
+    };
+    let mut required_assoc_items = FxHashSet::default();
+    let trait_candidates = unfiltered_imports
+        .filter_map(|input| match input {
+            Either::Left(module_def) => module_def.as_assoc_item(db),
+            _ => None,
+        })
+        .filter_map(|assoc| {
+            let assoc_item_trait = assoc.containing_trait(db)?;
+            required_assoc_items.insert(assoc);
+            Some(assoc_item_trait.into())
+        })
+        .collect();
+    let mut applicable_defs = FxHashSet::default();
+    match import_candidate {
+        ImportCandidate::Path(_) => unreachable!(),
+        ImportCandidate::TraitAssocItem(_) => receiver_ty.iterate_path_candidates(
+            db,
+            current_crate,
+            &trait_candidates,
+            None,
+            |_, assoc| {
+                if required_assoc_items.contains(&assoc) {
+                    if let AssocItem::Function(f) = assoc {
+                        if f.self_param(db).is_some() {
+                            return None;
+                        }
+                    }
+                    applicable_defs.insert(Either::Left(assoc_to_module_def(assoc)));
+                }
+                None::<()>
+            },
+        ),
+        ImportCandidate::TraitMethod(_) => receiver_ty.iterate_method_candidates(
+            db,
+            current_crate,
+            &trait_candidates,
+            None,
+            |_, function| {
+                let assoc = function.as_assoc_item(db)?;
+                if required_assoc_items.contains(&assoc) {
+                    applicable_defs.insert(Either::Left(assoc_to_module_def(assoc)));
+                }
+                None::<()>
+            },
+        ),
+    };
+    Box::new(applicable_defs.into_iter())
+}
+fn assoc_to_module_def(assoc: AssocItem) -> ModuleDef {
+    match assoc {
+        AssocItem::Function(f) => f.into(),
+        AssocItem::Const(c) => c.into(),
+        AssocItem::TypeAlias(t) => t.into(),
    }
 }
@@ -216,22 +315,19 @@ impl ImportCandidate {
        match sema.resolve_method_call(method_call) {
            Some(_) => None,
            None => Some(Self::TraitMethod(TraitImportCandidate {
-                ty: sema.type_of_expr(&method_call.receiver()?)?,
+                receiver_ty: sema.type_of_expr(&method_call.receiver()?)?,
-                name: method_call.name_ref()?,
+                name: NameToImport::Exact(method_call.name_ref()?.to_string()),
            })),
        }
    }
-    fn for_regular_path(
+    fn for_regular_path(sema: &Semantics<RootDatabase>, path: &ast::Path) -> Option<Self> {
-        sema: &Semantics<RootDatabase>,
+        if sema.resolve_path(path).is_some() {
-        path_under_caret: &ast::Path,
-    ) -> Option<Self> {
-        if sema.resolve_path(path_under_caret).is_some() {
            return None;
        }
-        let segment = path_under_caret.segment()?;
+        let segment = path.segment()?;
-        let candidate = if let Some(qualifier) = path_under_caret.qualifier() {
+        let candidate = if let Some(qualifier) = path.qualifier() {
            let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
            let qualifier_start_path =
                qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
@@ -244,8 +340,8 @@ impl ImportCandidate {
                match qualifier_resolution {
                    hir::PathResolution::Def(hir::ModuleDef::Adt(assoc_item_path)) => {
                        ImportCandidate::TraitAssocItem(TraitImportCandidate {
-                            ty: assoc_item_path.ty(sema.db),
+                            receiver_ty: assoc_item_path.ty(sema.db),
-                            name: segment.name_ref()?,
+                            name: NameToImport::Exact(segment.name_ref()?.to_string()),
                        })
                    }
                    _ => return None,
@@ -253,13 +349,15 @@ impl ImportCandidate {
            } else {
                ImportCandidate::Path(PathImportCandidate {
                    qualifier: Some(qualifier),
-                    name: qualifier_start,
+                    name: NameToImport::Exact(qualifier_start.to_string()),
                })
            }
        } else {
            ImportCandidate::Path(PathImportCandidate {
                qualifier: None,
-                name: segment.syntax().descendants().find_map(ast::NameRef::cast)?,
+                name: NameToImport::Exact(
+                    segment.syntax().descendants().find_map(ast::NameRef::cast)?.to_string(),
+                ),
            })
        };
        Some(candidate)
diff --git a/crates/ide_db/src/helpers/insert_use/tests.rs b/crates/ide_db/src/helpers/insert_use/tests.rs
index a603fe87f..4bbe66f1f 100644
--- a/crates/ide_db/src/helpers/insert_use/tests.rs
+++ b/crates/ide_db/src/helpers/insert_use/tests.rs
@@ -599,7 +599,7 @@ fn check(
    let rewriter = insert_use(&file, path, mb);
    let result = rewriter.rewrite(file.as_syntax_node()).to_string();
-    assert_eq_text!(&result, ra_fixture_after);
+    assert_eq_text!(ra_fixture_after, &result);
 }
 fn check_full(path: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs
index d111fba92..502e8281a 100644
--- a/crates/ide_db/src/imports_locator.rs
+++ b/crates/ide_db/src/imports_locator.rs
@@ -1,7 +1,10 @@
 //! This module contains an import search functionality that is provided to the assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the assists module.
-use hir::{import_map, AsAssocItem, Crate, MacroDef, ModuleDef, Semantics};
+use hir::{
+    import_map::{self, ImportKind},
+    AsAssocItem, Crate, MacroDef, ModuleDef, Semantics,
+};
 use syntax::{ast, AstNode, SyntaxKind::NAME};
 use crate::{
@@ -12,69 +15,84 @@ use crate::{
 use either::Either;
 use rustc_hash::FxHashSet;
-const QUERY_SEARCH_LIMIT: usize = 40;
+pub(crate) const DEFAULT_QUERY_SEARCH_LIMIT: usize = 40;
 pub fn find_exact_imports<'a>(
    sema: &Semantics<'a, RootDatabase>,
    krate: Crate,
    name_to_import: String,
-) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
+) -> Box<dyn Iterator<Item = Either<ModuleDef, MacroDef>>> {
    let _p = profile::span("find_exact_imports");
-    find_imports(
+    Box::new(find_imports(
        sema,
        krate,
        {
            let mut local_query = symbol_index::Query::new(name_to_import.clone());
            local_query.exact();
-            local_query.limit(QUERY_SEARCH_LIMIT);
+            local_query.limit(DEFAULT_QUERY_SEARCH_LIMIT);
            local_query
        },
        import_map::Query::new(name_to_import)
-            .limit(QUERY_SEARCH_LIMIT)
+            .limit(DEFAULT_QUERY_SEARCH_LIMIT)
            .name_only()
            .search_mode(import_map::SearchMode::Equals)
            .case_sensitive(),
-    )
+    ))
+}
+pub enum AssocItemSearch {
+    Include,
+    Exclude,
+    AssocItemsOnly,
 }
 pub fn find_similar_imports<'a>(
    sema: &Semantics<'a, RootDatabase>,
    krate: Crate,
-    limit: Option<usize>,
    fuzzy_search_string: String,
-    ignore_assoc_items: bool,
+    assoc_item_search: AssocItemSearch,
-    name_only: bool,
+    limit: Option<usize>,
-) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> + 'a {
+) -> Box<dyn Iterator<Item = Either<ModuleDef, MacroDef>> + 'a> {
    let _p = profile::span("find_similar_imports");
    let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
-        .search_mode(import_map::SearchMode::Fuzzy);
+        .search_mode(import_map::SearchMode::Fuzzy)
-    if name_only {
+        .name_only();
-        external_query = external_query.name_only();
+    match assoc_item_search {
+        AssocItemSearch::Include => {}
+        AssocItemSearch::Exclude => {
+            external_query = external_query.exclude_import_kind(ImportKind::AssociatedItem);
+        }
+        AssocItemSearch::AssocItemsOnly => {
+            external_query = external_query.assoc_items_only();
+        }
    }
    let mut local_query = symbol_index::Query::new(fuzzy_search_string);
    if let Some(limit) = limit {
-        local_query.limit(limit);
        external_query = external_query.limit(limit);
+        local_query.limit(limit);
    }
    let db = sema.db;
-    find_imports(sema, krate, local_query, external_query).filter(move |import_candidate| {
+    Box::new(find_imports(sema, krate, local_query, external_query).filter(
-        if ignore_assoc_items {
+        move |import_candidate| match assoc_item_search {
-            match import_candidate {
+            AssocItemSearch::Include => true,
-                Either::Left(ModuleDef::Function(function)) => function.as_assoc_item(db).is_none(),
+            AssocItemSearch::Exclude => !is_assoc_item(import_candidate, db),
-                Either::Left(ModuleDef::Const(const_)) => const_.as_assoc_item(db).is_none(),
+            AssocItemSearch::AssocItemsOnly => is_assoc_item(import_candidate, db),
-                Either::Left(ModuleDef::TypeAlias(type_alias)) => {
+        },
-                    type_alias.as_assoc_item(db).is_none()
+    ))
-                }
+}
-                _ => true,
-            }
+fn is_assoc_item(import_candidate: &Either<ModuleDef, MacroDef>, db: &RootDatabase) -> bool {
-        } else {
+    match import_candidate {
-            true
+        Either::Left(ModuleDef::Function(function)) => function.as_assoc_item(db).is_some(),
-        }
+        Either::Left(ModuleDef::Const(const_)) => const_.as_assoc_item(db).is_some(),
-    })
+        Either::Left(ModuleDef::TypeAlias(type_alias)) => type_alias.as_assoc_item(db).is_some(),
+        _ => false,
+    }
 }
 fn find_imports<'a>(
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index e648519f9..2a41d8167 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -51,6 +51,7 @@ pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, Toke
    let global_offset = node.text_range().start();
    let mut c = Convertor::new(node, global_offset);
    let subtree = c.go()?;
+    c.id_alloc.map.entries.shrink_to_fit();
    Some((subtree, c.id_alloc.map))
 }
@@ -593,7 +594,8 @@ impl<'a> TtTreeSink<'a> {
        }
    }
-    fn finish(self) -> (Parse<SyntaxNode>, TokenMap) {
+    fn finish(mut self) -> (Parse<SyntaxNode>, TokenMap) {
+        self.token_map.entries.shrink_to_fit();
        (self.inner.finish(), self.token_map)
    }
 }
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index 9ff901e97..bd2977ebd 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -261,7 +261,6 @@ fn test_expr_order() {
    let dump = format!("{:#?}", expanded);
    assert_eq_text!(
-        dump.trim(),
        r#"[email protected]
  [email protected]
    [email protected] "fn"
@@ -285,6 +284,7 @@ fn test_expr_order() {
            [email protected] "2"
        [email protected] ";"
      [email protected] "}""#,
+        dump.trim()
    );
 }
@@ -989,7 +989,6 @@ fn test_tt_composite2() {
    let res = format!("{:#?}", &node);
    assert_eq_text!(
-        res.trim(),
        r###"[email protected]
  [email protected]
    [email protected]
@@ -1003,7 +1002,8 @@ fn test_tt_composite2() {
      [email protected] ">"
      [email protected] " "
      [email protected] "#"
-      [email protected] ")""###
+      [email protected] ")""###,
+        res.trim()
    );
 }
@@ -1742,7 +1742,7 @@ impl MacroFixture {
    fn assert_expand(&self, invocation: &str, expected: &str) {
        let expansion = self.expand_tt(invocation);
        let actual = format!("{:?}", expansion);
-        test_utils::assert_eq_text!(&actual.trim(), &expected.trim());
+        test_utils::assert_eq_text!(&expected.trim(), &actual.trim());
    }
    fn assert_expand_items(&self, invocation: &str, expected: &str) -> &MacroFixture {
@@ -1941,7 +1941,6 @@ fn test_no_space_after_semi_colon() {
    let dump = format!("{:#?}", expanded);
    assert_eq_text!(
-        dump.trim(),
        r###"[email protected]
  [email protected]
    [email protected]
@@ -1981,6 +1980,7 @@ fn test_no_space_after_semi_colon() {
    [email protected]
      [email protected] "f"
    [email protected] ";""###,
+        dump.trim()
    );
 }
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index bb9ffea8b..6913e9ec2 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -190,17 +190,25 @@ fn opt_visibility(p: &mut Parser) -> bool {
                    // test crate_visibility
                    // pub(crate) struct S;
                    // pub(self) struct S;
-                    // pub(self) struct S;
+                    // pub(super) struct S;
-                    // pub(self) struct S;
                    // test pub_parens_typepath
                    // struct B(pub (super::A));
                    // struct B(pub (crate::A,));
                    T![crate] | T![self] | T![super] if p.nth(2) != T![:] => {
                        p.bump_any();
+                        let path_m = p.start();
+                        let path_segment_m = p.start();
+                        let name_ref_m = p.start();
                        p.bump_any();
+                        name_ref_m.complete(p, NAME_REF);
+                        path_segment_m.complete(p, PATH_SEGMENT);
+                        path_m.complete(p, PATH);
                        p.expect(T![')']);
                    }
+                    // test crate_visibility_in
+                    // pub(in super::A) struct S;
+                    // pub(in crate) struct S;
                    T![in] => {
                        p.bump_any();
                        p.bump_any();
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index 2070ce163..1d894e907 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -270,7 +270,9 @@ fn extern_crate(p: &mut Parser, m: Marker) {
    p.bump(T![crate]);
    if p.at(T![self]) {
+        let m = p.start();
        p.bump(T![self]);
+        m.complete(p, NAME_REF);
    } else {
        name_ref(p);
    }
diff --git a/crates/parser/src/grammar/items/traits.rs b/crates/parser/src/grammar/items/traits.rs
index d076974ed..d3327271c 100644
--- a/crates/parser/src/grammar/items/traits.rs
+++ b/crates/parser/src/grammar/items/traits.rs
@@ -40,6 +40,10 @@ pub(super) fn impl_(p: &mut Parser) {
        type_params::opt_generic_param_list(p);
    }
+    // test impl_def_const
+    // impl const Send for X {}
+    p.eat(T![const]);
    // FIXME: never type
    // impl ! {}
diff --git a/crates/parser/src/grammar/params.rs b/crates/parser/src/grammar/params.rs
index 2d006a1d5..6a98d7368 100644
--- a/crates/parser/src/grammar/params.rs
+++ b/crates/parser/src/grammar/params.rs
@@ -156,7 +156,7 @@ fn variadic_param(p: &mut Parser) -> bool {
 fn opt_self_param(p: &mut Parser, m: Marker) {
    if p.at(T![self]) || p.at(T![mut]) && p.nth(1) == T![self] {
        p.eat(T![mut]);
-        p.eat(T![self]);
+        self_as_name(p);
        // test arb_self_types
        // impl S {
        //     fn a(self: &Self) {}
@@ -169,24 +169,29 @@ fn opt_self_param(p: &mut Parser, m: Marker) {
        let la1 = p.nth(1);
        let la2 = p.nth(2);
        let la3 = p.nth(3);
-        let mut n_toks = match (p.current(), la1, la2, la3) {
+        if !matches!((p.current(), la1, la2, la3),
-            (T![&], T![self], _, _) => 2,
+              (T![&], T![self], _, _)
-            (T![&], T![mut], T![self], _) => 3,
+            | (T![&], T![mut], T![self], _)
-            (T![&], LIFETIME_IDENT, T![self], _) => 3,
+            | (T![&], LIFETIME_IDENT, T![self], _)
-            (T![&], LIFETIME_IDENT, T![mut], T![self]) => 4,
+            | (T![&], LIFETIME_IDENT, T![mut], T![self])
-            _ => return m.abandon(p),
+        ) {
-        };
+            return m.abandon(p);
-        p.bump_any();
+        }
+        p.bump(T![&]);
        if p.at(LIFETIME_IDENT) {
            lifetime(p);
-            n_toks -= 1;
-        }
-        for _ in 1..n_toks {
-            p.bump_any();
        }
+        p.eat(T![mut]);
+        self_as_name(p);
    }
    m.complete(p, SELF_PARAM);
    if !p.at(T![')']) {
        p.expect(T![,]);
    }
 }
+fn self_as_name(p: &mut Parser) {
+    let m = p.start();
+    p.bump(T![self]);
+    m.complete(p, NAME);
+}
diff --git a/crates/parser/src/syntax_kind.rs b/crates/parser/src/syntax_kind.rs
index 63204436c..9ea0e4f9b 100644
--- a/crates/parser/src/syntax_kind.rs
+++ b/crates/parser/src/syntax_kind.rs
@@ -6,6 +6,7 @@ mod generated;
 pub use self::generated::SyntaxKind;
 impl From<u16> for SyntaxKind {
+    #[inline]
    fn from(d: u16) -> SyntaxKind {
        assert!(d <= (SyntaxKind::__LAST as u16));
        unsafe { std::mem::transmute::<u16, SyntaxKind>(d) }
@@ -13,12 +14,14 @@ impl From<u16> for SyntaxKind {
 }
 impl From<SyntaxKind> for u16 {
+    #[inline]
    fn from(k: SyntaxKind) -> u16 {
        k as u16
    }
 }
 impl SyntaxKind {
+    #[inline]
    pub fn is_trivia(self) -> bool {
        matches!(self, SyntaxKind::WHITESPACE | SyntaxKind::COMMENT)
    }
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs
index 7d53cc4cd..bcefd183a 100644
--- a/crates/parser/src/syntax_kind/generated.rs
+++ b/crates/parser/src/syntax_kind/generated.rs
@@ -143,6 +143,7 @@ pub enum SyntaxKind {
    MACRO_DEF,
    PAREN_TYPE,
    TUPLE_TYPE,
+    MACRO_TYPE,
    NEVER_TYPE,
    PATH_TYPE,
    PTR_TYPE,
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index 1af2bbca7..078568cb2 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["unbounded_depth"] }
 log = "0.4.8"
 crossbeam-channel = "0.5.0"
 jod-thread = "0.1.1"
diff --git a/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt b/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
index e6fd21610..ea34e688f 100644
--- a/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
+++ b/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
@@ -59,7 +59,7 @@ SUBTREE $
          IDENT   _serde 4294967295
          PUNCH   : [joint] 4294967295
          PUNCH   : [alone] 4294967295
-          IDENT   export 4294967295
+          IDENT   __private 4294967295
          PUNCH   : [joint] 4294967295
          PUNCH   : [alone] 4294967295
          IDENT   Ok 4294967295
@@ -72,7 +72,7 @@ SUBTREE $
          IDENT   _serde 4294967295
          PUNCH   : [joint] 4294967295
          PUNCH   : [alone] 4294967295
-          IDENT   export 4294967295
+          IDENT   __private 4294967295
          PUNCH   : [joint] 4294967295
          PUNCH   : [alone] 4294967295
          IDENT   Err 4294967295
@@ -85,7 +85,7 @@ SUBTREE $
            IDENT   _serde 4294967295
            PUNCH   : [joint] 4294967295
            PUNCH   : [alone] 4294967295
-            IDENT   export 4294967295
+            IDENT   __private 4294967295
            PUNCH   : [joint] 4294967295
            PUNCH   : [alone] 4294967295
            IDENT   Err 4294967295
@@ -120,7 +120,7 @@ SUBTREE $
      IDENT   _serde 4294967295
      PUNCH   : [joint] 4294967295
      PUNCH   : [alone] 4294967295
-      IDENT   export 4294967295
+      IDENT   __private 4294967295
      PUNCH   : [joint] 4294967295
      PUNCH   : [alone] 4294967295
      IDENT   Result 4294967295
diff --git a/crates/proc_macro_srv/src/tests/mod.rs b/crates/proc_macro_srv/src/tests/mod.rs
index 1a827cbd7..fd54f8dfd 100644
--- a/crates/proc_macro_srv/src/tests/mod.rs
+++ b/crates/proc_macro_srv/src/tests/mod.rs
@@ -38,9 +38,9 @@ fn test_derive_proc_macro_list() {
    let res = list("serde_derive", "1").join("\n");
    assert_eq_text!(
-        &res,
        r#"Serialize [CustomDerive]
-Deserialize [CustomDerive]"#
+Deserialize [CustomDerive]"#,
+        &res
    );
 }
@@ -50,9 +50,9 @@ fn list_test_macros() {
    let res = list("proc_macro_test", "0.0.0").join("\n");
    assert_eq_text!(
-        &res,
        r#"function_like_macro [FuncLike]
 attribute_macro [Attr]
-DummyTrait [CustomDerive]"#
+DummyTrait [CustomDerive]"#,
+        &res
    );
 }
diff --git a/crates/proc_macro_srv/src/tests/utils.rs b/crates/proc_macro_srv/src/tests/utils.rs
index 36942147d..196abb8fc 100644
--- a/crates/proc_macro_srv/src/tests/utils.rs
+++ b/crates/proc_macro_srv/src/tests/utils.rs
@@ -52,7 +52,7 @@ pub fn assert_expand(
    let fixture = parse_string(ra_fixture).unwrap();
    let res = expander.expand(macro_name, &fixture.subtree, None).unwrap();
-    assert_eq_text!(&format!("{:?}", res), &expect.trim());
+    assert_eq_text!(&expect.trim(), &format!("{:?}", res));
 }
 pub fn list(crate_name: &str, version: &str) -> Vec<String> {
diff --git a/crates/profile/Cargo.toml b/crates/profile/Cargo.toml
index 9c7ce26be..f7231c2b8 100644
--- a/crates/profile/Cargo.toml
+++ b/crates/profile/Cargo.toml
@@ -14,12 +14,14 @@ once_cell = "1.3.1"
 cfg-if = "1"
 libc = "0.2.73"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
+jemalloc-ctl = { version = "0.3.3", optional = true }
 [target.'cfg(target_os = "linux")'.dependencies]
 perf-event = "0.4"
 [features]
 cpu_profiler = []
+jemalloc = ["jemalloc-ctl"]
 # Uncomment to enable for the whole crate graph
 # default = [ "cpu_profiler" ]
diff --git a/crates/profile/src/memory_usage.rs b/crates/profile/src/memory_usage.rs
index 83390212a..cb4e54447 100644
--- a/crates/profile/src/memory_usage.rs
+++ b/crates/profile/src/memory_usage.rs
@@ -24,7 +24,12 @@ impl std::ops::Sub for MemoryUsage {
 impl MemoryUsage {
    pub fn current() -> MemoryUsage {
        cfg_if! {
-            if #[cfg(all(target_os = "linux", target_env = "gnu"))] {
+            if #[cfg(all(feature = "jemalloc", not(target_env = "msvc")))] {
+                jemalloc_ctl::epoch::advance().unwrap();
+                MemoryUsage {
+                    allocated: Bytes(jemalloc_ctl::stats::allocated::read().unwrap() as isize),
+                }
+            } else if #[cfg(all(target_os = "linux", target_env = "gnu"))] {
                // Note: This is incredibly slow.
                let alloc = unsafe { libc::mallinfo() }.uordblks as isize;
                MemoryUsage { allocated: Bytes(alloc) }
diff --git a/crates/project_model/Cargo.toml b/crates/project_model/Cargo.toml
index 436eff16b..293cb5bfe 100644
--- a/crates/project_model/Cargo.toml
+++ b/crates/project_model/Cargo.toml
@@ -25,3 +25,4 @@ toolchain = { path = "../toolchain", version = "0.0.0" }
 proc_macro_api =  { path = "../proc_macro_api", version = "0.0.0" }
 paths =  { path = "../paths", version = "0.0.0" }
 stdx =  { path = "../stdx", version = "0.0.0" }
+profile =  { path = "../profile", version = "0.0.0" }
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index aabb7a47d..970a7e140 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -5,6 +5,7 @@ mod cfg_flag;
 mod project_json;
 mod sysroot;
 mod workspace;
+mod rustc_cfg;
 use std::{
    fs::{read_dir, ReadDir},
diff --git a/crates/project_model/src/rustc_cfg.rs b/crates/project_model/src/rustc_cfg.rs
new file mode 100644
index 000000000..4a7bd8ae3
--- /dev/null
+++ b/crates/project_model/src/rustc_cfg.rs
@@ -0,0 +1,34 @@
+//! Runs `rustc --print cfg` to get built-in cfg flags.
+use std::process::Command;
+use crate::{cfg_flag::CfgFlag, utf8_stdout};
+pub(crate) fn get(target: Option<&str>) -> Vec<CfgFlag> {
+    let _p = profile::span("rustc_cfg::get");
+    let mut res = Vec::new();
+    // Some nightly-only cfgs, which are required for stdlib
+    res.push(CfgFlag::Atom("target_thread_local".into()));
+    for &ty in ["8", "16", "32", "64", "cas", "ptr"].iter() {
+        for &key in ["target_has_atomic", "target_has_atomic_load_store"].iter() {
+            res.push(CfgFlag::KeyValue { key: key.to_string(), value: ty.into() });
+        }
+    }
+    let rustc_cfgs = {
+        let mut cmd = Command::new(toolchain::rustc());
+        cmd.args(&["--print", "cfg", "-O"]);
+        if let Some(target) = target {
+            cmd.args(&["--target", target]);
+        }
+        utf8_stdout(cmd)
+    };
+    match rustc_cfgs {
+        Ok(rustc_cfgs) => res.extend(rustc_cfgs.lines().map(|it| it.parse().unwrap())),
+        Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
+    }
+    res
+}
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index 06a0be284..8e0481ae9 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -16,7 +16,7 @@ use proc_macro_api::ProcMacroClient;
 use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
-    cargo_workspace, cfg_flag::CfgFlag, sysroot::SysrootCrate, utf8_stdout, CargoConfig,
+    cargo_workspace, cfg_flag::CfgFlag, rustc_cfg, sysroot::SysrootCrate, utf8_stdout, CargoConfig,
    CargoWorkspace, ProjectJson, ProjectManifest, Sysroot, TargetKind,
 };
@@ -34,15 +34,25 @@ pub struct PackageRoot {
 #[derive(Clone, Eq, PartialEq)]
 pub enum ProjectWorkspace {
    /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
-    Cargo { cargo: CargoWorkspace, sysroot: Sysroot, rustc: Option<CargoWorkspace> },
+    Cargo {
+        cargo: CargoWorkspace,
+        sysroot: Sysroot,
+        rustc: Option<CargoWorkspace>,
+        /// Holds cfg flags for the current target. We get those by running
+        /// `rustc --print cfg`.
+        ///
+        /// FIXME: make this a per-crate map, as, eg, build.rs might have a
+        /// different target.
+        rustc_cfg: Vec<CfgFlag>,
+    },
    /// Project workspace was manually specified using a `rust-project.json` file.
-    Json { project: ProjectJson, sysroot: Option<Sysroot> },
+    Json { project: ProjectJson, sysroot: Option<Sysroot>, rustc_cfg: Vec<CfgFlag> },
 }
 impl fmt::Debug for ProjectWorkspace {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => f
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg } => f
                .debug_struct("Cargo")
                .field("n_packages", &cargo.packages().len())
                .field("n_sysroot_crates", &sysroot.crates().len())
@@ -50,13 +60,15 @@ impl fmt::Debug for ProjectWorkspace {
                    "n_rustc_compiler_crates",
                    &rustc.as_ref().map_or(0, |rc| rc.packages().len()),
                )
+                .field("rustc_cfg", rustc_cfg)
                .finish(),
-            ProjectWorkspace::Json { project, sysroot } => {
+            ProjectWorkspace::Json { project, sysroot, rustc_cfg } => {
                let mut debug_struct = f.debug_struct("Json");
                debug_struct.field("n_crates", &project.n_crates());
                if let Some(sysroot) = sysroot {
                    debug_struct.field("n_sysroot_crates", &sysroot.crates().len());
                }
+                debug_struct.field("rustc_cfg", rustc_cfg);
                debug_struct.finish()
            }
        }
@@ -79,7 +91,7 @@ impl ProjectWorkspace {
                })?;
                let project_location = project_json.parent().unwrap().to_path_buf();
                let project_json = ProjectJson::new(&project_location, data);
-                ProjectWorkspace::load_inline(project_json)?
+                ProjectWorkspace::load_inline(project_json, config.target.as_deref())?
            }
            ProjectManifest::CargoToml(cargo_toml) => {
                let cargo_version = utf8_stdout({
@@ -117,21 +129,24 @@ impl ProjectWorkspace {
                } else {
                    None
                };
+                let rustc_cfg = rustc_cfg::get(config.target.as_deref());
-                ProjectWorkspace::Cargo { cargo, sysroot, rustc }
+                ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg }
            }
        };
        Ok(res)
    }
-    pub fn load_inline(project_json: ProjectJson) -> Result<ProjectWorkspace> {
+    pub fn load_inline(
+        project_json: ProjectJson,
+        target: Option<&str>,
+    ) -> Result<ProjectWorkspace> {
        let sysroot = match &project_json.sysroot_src {
            Some(path) => Some(Sysroot::load(path)?),
            None => None,
        };
+        let rustc_cfg = rustc_cfg::get(target);
-        Ok(ProjectWorkspace::Json { project: project_json, sysroot })
+        Ok(ProjectWorkspace::Json { project: project_json, sysroot, rustc_cfg })
    }
    /// Returns the roots for the current `ProjectWorkspace`
@@ -139,7 +154,7 @@ impl ProjectWorkspace {
    /// the root is a member of the current workspace
    pub fn to_roots(&self) -> Vec<PackageRoot> {
        match self {
-            ProjectWorkspace::Json { project, sysroot } => project
+            ProjectWorkspace::Json { project, sysroot, rustc_cfg: _ } => project
                .crates()
                .map(|(_, krate)| PackageRoot {
                    is_member: krate.is_workspace_member,
@@ -156,7 +171,7 @@ impl ProjectWorkspace {
                    })
                }))
                .collect::<Vec<_>>(),
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => cargo
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg: _ } => cargo
                .packages()
                .map(|pkg| {
                    let is_member = cargo[pkg].is_member;
@@ -194,7 +209,7 @@ impl ProjectWorkspace {
    pub fn n_packages(&self) -> usize {
        match self {
            ProjectWorkspace::Json { project, .. } => project.n_crates(),
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => {
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, .. } => {
                let rustc_package_len = rustc.as_ref().map_or(0, |rc| rc.packages().len());
                cargo.packages().len() + sysroot.crates().len() + rustc_package_len
            }
@@ -203,22 +218,31 @@ impl ProjectWorkspace {
    pub fn to_crate_graph(
        &self,
-        target: Option<&str>,
        proc_macro_client: Option<&ProcMacroClient>,
        load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
    ) -> CrateGraph {
+        let _p = profile::span("ProjectWorkspace::to_crate_graph");
        let proc_macro_loader = |path: &Path| match proc_macro_client {
            Some(client) => client.by_dylib_path(path),
            None => Vec::new(),
        };
        let mut crate_graph = match self {
-            ProjectWorkspace::Json { project, sysroot } => {
+            ProjectWorkspace::Json { project, sysroot, rustc_cfg } => project_json_to_crate_graph(
-                project_json_to_crate_graph(target, &proc_macro_loader, load, project, sysroot)
+                rustc_cfg.clone(),
-            }
+                &proc_macro_loader,
-            ProjectWorkspace::Cargo { cargo, sysroot, rustc } => {
+                load,
-                cargo_to_crate_graph(target, &proc_macro_loader, load, cargo, sysroot, rustc)
+                project,
-            }
+                sysroot,
+            ),
+            ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg } => cargo_to_crate_graph(
+                rustc_cfg.clone(),
+                &proc_macro_loader,
+                load,
+                cargo,
+                sysroot,
+                rustc,
+            ),
        };
        if crate_graph.patch_cfg_if() {
            log::debug!("Patched std to depend on cfg-if")
@@ -230,7 +254,7 @@ impl ProjectWorkspace {
 }
 fn project_json_to_crate_graph(
-    target: Option<&str>,
+    rustc_cfg: Vec<CfgFlag>,
    proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
    project: &ProjectJson,
@@ -239,9 +263,9 @@ fn project_json_to_crate_graph(
    let mut crate_graph = CrateGraph::default();
    let sysroot_deps = sysroot
        .as_ref()
-        .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load));
+        .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load));
-    let mut cfg_cache: FxHashMap<Option<&str>, Vec<CfgFlag>> = FxHashMap::default();
+    let mut cfg_cache: FxHashMap<&str, Vec<CfgFlag>> = FxHashMap::default();
    let crates: FxHashMap<CrateId, CrateId> = project
        .crates()
        .filter_map(|(crate_id, krate)| {
@@ -253,9 +277,12 @@ fn project_json_to_crate_graph(
            let env = krate.env.clone().into_iter().collect();
            let proc_macro = krate.proc_macro_dylib_path.clone().map(|it| proc_macro_loader(&it));
-            let target = krate.target.as_deref().or(target);
+            let target_cfgs = match krate.target.as_deref() {
-            let target_cfgs =
+                Some(target) => {
-                cfg_cache.entry(target).or_insert_with(|| get_rustc_cfg_options(target));
+                    cfg_cache.entry(target).or_insert_with(|| rustc_cfg::get(Some(target)))
+                }
+                None => &rustc_cfg,
+            };
            let mut cfg_options = CfgOptions::default();
            cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned());
@@ -292,19 +319,20 @@ fn project_json_to_crate_graph(
 }
 fn cargo_to_crate_graph(
-    target: Option<&str>,
+    rustc_cfg: Vec<CfgFlag>,
    proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
    cargo: &CargoWorkspace,
    sysroot: &Sysroot,
    rustc: &Option<CargoWorkspace>,
 ) -> CrateGraph {
+    let _p = profile::span("cargo_to_crate_graph");
    let mut crate_graph = CrateGraph::default();
    let (public_deps, libproc_macro) =
-        sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load);
+        sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load);
    let mut cfg_options = CfgOptions::default();
-    cfg_options.extend(get_rustc_cfg_options(target));
+    cfg_options.extend(rustc_cfg);
    let mut pkg_to_lib_crate = FxHashMap::default();
@@ -490,11 +518,12 @@ fn add_target_crate_root(
 fn sysroot_to_crate_graph(
    crate_graph: &mut CrateGraph,
    sysroot: &Sysroot,
-    target: Option<&str>,
+    rustc_cfg: Vec<CfgFlag>,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 ) -> (Vec<(CrateName, CrateId)>, Option<CrateId>) {
+    let _p = profile::span("sysroot_to_crate_graph");
    let mut cfg_options = CfgOptions::default();
-    cfg_options.extend(get_rustc_cfg_options(target));
+    cfg_options.extend(rustc_cfg);
    let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = sysroot
        .crates()
        .filter_map(|krate| {
@@ -533,34 +562,6 @@ fn sysroot_to_crate_graph(
    (public_deps, libproc_macro)
 }
-fn get_rustc_cfg_options(target: Option<&str>) -> Vec<CfgFlag> {
-    let mut res = Vec::new();
-    // Some nightly-only cfgs, which are required for stdlib
-    res.push(CfgFlag::Atom("target_thread_local".into()));
-    for &ty in ["8", "16", "32", "64", "cas", "ptr"].iter() {
-        for &key in ["target_has_atomic", "target_has_atomic_load_store"].iter() {
-            res.push(CfgFlag::KeyValue { key: key.to_string(), value: ty.into() });
-        }
-    }
-    let rustc_cfgs = {
-        let mut cmd = Command::new(toolchain::rustc());
-        cmd.args(&["--print", "cfg", "-O"]);
-        if let Some(target) = target {
-            cmd.args(&["--target", target]);
-        }
-        utf8_stdout(cmd)
-    };
-    match rustc_cfgs {
-        Ok(rustc_cfgs) => res.extend(rustc_cfgs.lines().map(|it| it.parse().unwrap())),
-        Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
-    }
-    res
-}
 fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) {
    if let Err(err) = graph.add_dep(from, name, to) {
        log::error!("{}", err)
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index af7b86ead..3cb45b030 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -61,8 +61,14 @@ proc_macro_srv = { path = "../proc_macro_srv", version = "0.0.0" }
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.8"
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+jemallocator = { version = "0.3.2", optional = true }
 [dev-dependencies]
 expect-test = "1.1"
 test_utils = { path = "../test_utils" }
 mbe = { path = "../mbe" }
 tt = { path = "../tt" }
+[features]
+jemalloc = ["jemallocator", "profile/jemalloc"]
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index bf42654a8..2f7f94a39 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -15,6 +15,10 @@ use vfs::AbsPathBuf;
 #[global_allocator]
 static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+#[cfg(all(feature = "jemalloc", not(target_env = "msvc")))]
+#[global_allocator]
+static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 fn main() {
    if let Err(err) = try_main() {
        eprintln!("{}", err);
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index a02c8327f..a01b49822 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -93,7 +93,7 @@ impl BenchCmd {
                if is_completion {
                    let options = 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),
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 31a16ca46..16ccab781 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -39,7 +39,7 @@ pub fn load_cargo(
        None
    };
-    let crate_graph = ws.to_crate_graph(None, proc_macro_client.as_ref(), &mut |path: &AbsPath| {
+    let crate_graph = ws.to_crate_graph(proc_macro_client.as_ref(), &mut |path: &AbsPath| {
        let contents = loader.load_sync(path);
        let path = vfs::VfsPath::from(path.to_path_buf());
        vfs.set_file_contents(path.clone(), contents);
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index ce9655818..3ddb9e19a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -559,7 +559,7 @@ impl Config {
    pub fn completion(&self) -> CompletionConfig {
        CompletionConfig {
            enable_postfix_completions: self.data.completion_postfix_enable,
-            enable_autoimport_completions: self.data.completion_autoimport_enable
+            enable_imports_on_the_fly: self.data.completion_autoimport_enable
                && completion_item_edit_resolve(&self.caps),
            add_call_parenthesis: self.data.completion_addCallParenthesis,
            add_call_argument_snippets: self.data.completion_addCallArgumentSnippets,
@@ -581,18 +581,7 @@ impl Config {
        AssistConfig {
            snippet_cap: SnippetCap::new(self.experimental("snippetTextEdit")),
            allowed: None,
-            insert_use: InsertUseConfig {
+            insert_use: self.insert_use_config(),
-                merge: match self.data.assist_importMergeBehavior {
-                    MergeBehaviorDef::None => None,
-                    MergeBehaviorDef::Full => Some(MergeBehavior::Full),
-                    MergeBehaviorDef::Last => Some(MergeBehavior::Last),
-                },
-                prefix_kind: match self.data.assist_importPrefix {
-                    ImportPrefixDef::Plain => PrefixKind::Plain,
-                    ImportPrefixDef::ByCrate => PrefixKind::ByCrate,
-                    ImportPrefixDef::BySelf => PrefixKind::BySelf,
-                },
-            },
        }
    }
    pub fn call_info_full(&self) -> bool {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 1a4e0dd32..001f3a37d 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -653,7 +653,7 @@ pub(crate) fn handle_completion(
            let mut new_completion_items =
                to_proto::completion_item(&line_index, line_endings, item.clone());
-            if completion_config.enable_autoimport_completions {
+            if completion_config.enable_imports_on_the_fly {
                for new_item in &mut new_completion_items {
                    fill_resolve_data(&mut new_item.data, &item, &text_document_position);
                }
@@ -703,6 +703,7 @@ pub(crate) fn handle_completion_resolve(
            FilePosition { file_id, offset },
            &resolve_data.full_import_path,
            resolve_data.imported_name,
+            resolve_data.import_for_trait_assoc_item,
        )?
        .into_iter()
        .flat_map(|edit| {
@@ -809,7 +810,7 @@ pub(crate) fn handle_rename(
    let change =
        snap.analysis.rename(position, &*params.new_name)?.map_err(to_proto::rename_error)?;
-    let workspace_edit = to_proto::workspace_edit(&snap, change.info)?;
+    let workspace_edit = to_proto::workspace_edit(&snap, change)?;
    Ok(Some(workspace_edit))
 }
@@ -1694,6 +1695,7 @@ struct CompletionResolveData {
    position: lsp_types::TextDocumentPositionParams,
    full_import_path: String,
    imported_name: String,
+    import_for_trait_assoc_item: bool,
 }
 fn fill_resolve_data(
@@ -1710,6 +1712,7 @@ fn fill_resolve_data(
            position: position.to_owned(),
            full_import_path,
            imported_name,
+            import_for_trait_assoc_item: import_edit.import_for_trait_assoc_item,
        })
        .unwrap(),
    );
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 97e20362f..dabfb4241 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -135,7 +135,10 @@ impl GlobalState {
                            )
                        }
                        LinkedProject::InlineJsonProject(it) => {
-                            project_model::ProjectWorkspace::load_inline(it.clone())
+                            project_model::ProjectWorkspace::load_inline(
+                                it.clone(),
+                                cargo_config.target.as_deref(),
+                            )
                        }
                    })
                    .collect::<Vec<_>>();
@@ -253,11 +256,7 @@ impl GlobalState {
                res
            };
            for ws in workspaces.iter() {
-                crate_graph.extend(ws.to_crate_graph(
+                crate_graph.extend(ws.to_crate_graph(self.proc_macro_client.as_ref(), &mut load));
-                    self.config.cargo().target.as_deref(),
-                    self.proc_macro_client.as_ref(),
-                    &mut load,
-                ));
            }
            crate_graph
@@ -274,6 +273,7 @@ impl GlobalState {
    }
    fn reload_flycheck(&mut self) {
+        let _p = profile::span("GlobalState::reload_flycheck");
        let config = match self.config.flycheck() {
            Some(it) => it,
            None => {
@@ -288,9 +288,7 @@ impl GlobalState {
            .iter()
            .enumerate()
            .filter_map(|(id, w)| match w {
-                ProjectWorkspace::Cargo { cargo, sysroot: _, rustc: _ } => {
+                ProjectWorkspace::Cargo { cargo, .. } => Some((id, cargo.workspace_root())),
-                    Some((id, cargo.workspace_root()))
-                }
                ProjectWorkspace::Json { project, .. } => {
                    // Enable flychecks for json projects if a custom flycheck command was supplied
                    // in the workspace configuration.
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 1ff2d3fea..0e3550002 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -884,7 +884,7 @@ mod tests {
            .completions(
                &ide::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),
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 1d722db3c..5baa54a3f 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -11,6 +11,7 @@ pub struct Name {
 }
 impl Name {
    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NameRef {
@@ -238,7 +239,6 @@ impl ExternCrate {
    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
@@ -406,9 +406,6 @@ pub struct Visibility {
 impl Visibility {
    pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
-    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
@@ -492,11 +489,11 @@ pub struct SelfParam {
    pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for SelfParam {}
+impl ast::NameOwner for SelfParam {}
 impl SelfParam {
    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 }
@@ -1075,6 +1072,13 @@ impl InferType {
    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroType {
+    pub(crate) syntax: SyntaxNode,
+}
+impl MacroType {
+    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
    pub(crate) syntax: SyntaxNode,
 }
@@ -1303,6 +1307,7 @@ pub enum Type {
    ForType(ForType),
    ImplTraitType(ImplTraitType),
    InferType(InferType),
+    MacroType(MacroType),
    NeverType(NeverType),
    ParenType(ParenType),
    PathType(PathType),
@@ -2561,6 +2566,17 @@ impl AstNode for InferType {
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for MacroType {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for NeverType {
    fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2892,6 +2908,9 @@ impl From<ImplTraitType> for Type {
 impl From<InferType> for Type {
    fn from(node: InferType) -> Type { Type::InferType(node) }
 }
+impl From<MacroType> for Type {
+    fn from(node: MacroType) -> Type { Type::MacroType(node) }
+}
 impl From<NeverType> for Type {
    fn from(node: NeverType) -> Type { Type::NeverType(node) }
 }
@@ -2917,8 +2936,8 @@ impl AstNode for Type {
    fn can_cast(kind: SyntaxKind) -> bool {
        match kind {
            ARRAY_TYPE | DYN_TRAIT_TYPE | FN_PTR_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE | INFER_TYPE
-            | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE | SLICE_TYPE
+            | MACRO_TYPE | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE
-            | TUPLE_TYPE => true,
+            | SLICE_TYPE | TUPLE_TYPE => true,
            _ => false,
        }
    }
@@ -2930,6 +2949,7 @@ impl AstNode for Type {
            FOR_TYPE => Type::ForType(ForType { syntax }),
            IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
            INFER_TYPE => Type::InferType(InferType { syntax }),
+            MACRO_TYPE => Type::MacroType(MacroType { syntax }),
            NEVER_TYPE => Type::NeverType(NeverType { syntax }),
            PAREN_TYPE => Type::ParenType(ParenType { syntax }),
            PATH_TYPE => Type::PathType(PathType { syntax }),
@@ -2949,6 +2969,7 @@ impl AstNode for Type {
            Type::ForType(it) => &it.syntax,
            Type::ImplTraitType(it) => &it.syntax,
            Type::InferType(it) => &it.syntax,
+            Type::MacroType(it) => &it.syntax,
            Type::NeverType(it) => &it.syntax,
            Type::ParenType(it) => &it.syntax,
            Type::PathType(it) => &it.syntax,
@@ -4085,6 +4106,11 @@ impl std::fmt::Display for InferType {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
+impl std::fmt::Display for MacroType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for NeverType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index b8ce71d27..738c92a5b 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -198,6 +198,13 @@ impl ast::Path {
    pub fn parent_path(&self) -> Option<ast::Path> {
        self.syntax().parent().and_then(ast::Path::cast)
    }
+    pub fn as_single_segment(&self) -> Option<ast::PathSegment> {
+        match self.qualifier() {
+            Some(_) => None,
+            None => self.segment(),
+        }
+    }
 }
 impl ast::UseTreeList {
@@ -448,16 +455,22 @@ pub enum VisibilityKind {
 impl ast::Visibility {
    pub fn kind(&self) -> VisibilityKind {
-        if let Some(path) = support::children(self.syntax()).next() {
+        match self.path() {
-            VisibilityKind::In(path)
+            Some(path) => {
-        } else if self.crate_token().is_some() {
+                if let Some(segment) =
-            VisibilityKind::PubCrate
+                    path.as_single_segment().filter(|it| it.coloncolon_token().is_none())
-        } else if self.super_token().is_some() {
+                {
-            VisibilityKind::PubSuper
+                    if segment.crate_token().is_some() {
-        } else if self.self_token().is_some() {
+                        return VisibilityKind::PubCrate;
-            VisibilityKind::PubSelf
+                    } else if segment.super_token().is_some() {
-        } else {
+                        return VisibilityKind::PubSuper;
-            VisibilityKind::Pub
+                    } else if segment.self_token().is_some() {
+                        return VisibilityKind::PubSelf;
+                    }
+                }
+                VisibilityKind::In(path)
+            }
+            None => VisibilityKind::Pub,
        }
    }
 }
diff --git a/crates/syntax/test_data/parser/err/0037_visibility_in_traits.rast b/crates/syntax/test_data/parser/err/0037_visibility_in_traits.rast
index faf87d6e5..ae4dd2f3b 100644
--- a/crates/syntax/test_data/parser/err/0037_visibility_in_traits.rast
+++ b/crates/syntax/test_data/parser/err/0037_visibility_in_traits.rast
@@ -50,7 +50,10 @@ [email protected]
        [email protected]
          [email protected] "pub"
          [email protected] "("
-          [email protected] "crate"
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "crate"
          [email protected] ")"
        [email protected] " "
        [email protected] "type"
@@ -69,7 +72,10 @@ [email protected]
        [email protected]
          [email protected] "pub"
          [email protected] "("
-          [email protected] "crate"
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "crate"
          [email protected] ")"
        [email protected] " "
        [email protected] "const"
diff --git a/crates/syntax/test_data/parser/inline/ok/0006_self_param.rast b/crates/syntax/test_data/parser/inline/ok/0006_self_param.rast
index 8048f5fad..f0d152d33 100644
--- a/crates/syntax/test_data/parser/inline/ok/0006_self_param.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0006_self_param.rast
@@ -19,7 +19,8 @@ [email protected]
        [email protected]
          [email protected] "("
          [email protected]
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -35,7 +36,8 @@ [email protected]
          [email protected] "("
          [email protected]
            [email protected] "&"
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ","
          [email protected] ")"
        [email protected] " "
@@ -55,7 +57,8 @@ [email protected]
            [email protected]
              [email protected] "\'a"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ","
          [email protected] ")"
        [email protected] " "
@@ -77,7 +80,8 @@ [email protected]
            [email protected] " "
            [email protected] "mut"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ","
          [email protected] " "
          [email protected]
@@ -107,7 +111,8 @@ [email protected]
          [email protected]
            [email protected] "mut"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0018_arb_self_types.rast b/crates/syntax/test_data/parser/inline/ok/0018_arb_self_types.rast
index ddbd66588..df59f37a2 100644
--- a/crates/syntax/test_data/parser/inline/ok/0018_arb_self_types.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0018_arb_self_types.rast
@@ -19,7 +19,8 @@ [email protected]
        [email protected]
          [email protected] "("
          [email protected]
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
            [email protected] ":"
            [email protected] " "
            [email protected]
@@ -45,7 +46,8 @@ [email protected]
          [email protected]
            [email protected] "mut"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
            [email protected] ":"
            [email protected] " "
            [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0021_impl_item_list.rast b/crates/syntax/test_data/parser/inline/ok/0021_impl_item_list.rast
index ca0702aba..dc7f6295b 100644
--- a/crates/syntax/test_data/parser/inline/ok/0021_impl_item_list.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0021_impl_item_list.rast
@@ -67,7 +67,8 @@ [email protected]
          [email protected] "("
          [email protected]
            [email protected] "&"
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rast b/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rast
index 50742cbcf..f2ead8a62 100644
--- a/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rast
@@ -1,9 +1,12 @@
-SOURCE_FILE@0..81
+SOURCE_FILE@0..62
  [email protected]
    [email protected]
      [email protected] "pub"
      [email protected] "("
-      [email protected] "crate"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "crate"
      [email protected] ")"
    [email protected] " "
    [email protected] "struct"
@@ -16,7 +19,10 @@ [email protected]
    [email protected]
      [email protected] "pub"
      [email protected] "("
-      [email protected] "self"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "self"
      [email protected] ")"
    [email protected] " "
    [email protected] "struct"
@@ -25,29 +31,19 @@ [email protected]
      [email protected] "S"
    [email protected] ";"
  [email protected] "\n"
-  [email protected]0
+  [email protected]1
-    [email protected]0
+    [email protected]1
      [email protected] "pub"
      [email protected] "("
-      [email protected] "self"
+      [email protected]
-      [email protected] ")"
+        [email protected]
-    [email protected] " "
+          [email protected]
-    [email protected] "struct"
+            [email protected] "super"
-    [email protected] " "
+      [email protected] ")"
-    [email protected]
+    [email protected] " "
-      [email protected] "S"
+    [email protected] "struct"
-    [email protected] ";"
+    [email protected] " "
-  [email protected] "\n"
+    [email protected]
-  [email protected]
+      [email protected] "S"
-    [email protected]
+    [email protected] ";"
-      [email protected] "pub"
+  [email protected] "\n"
-      [email protected] "("
-      [email protected] "self"
-      [email protected] ")"
-    [email protected] " "
-    [email protected] "struct"
-    [email protected] " "
-    [email protected]
-      [email protected] "S"
-    [email protected] ";"
-  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rs b/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rs
index faeefde94..a790a485f 100644
--- a/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rs
+++ b/crates/syntax/test_data/parser/inline/ok/0022_crate_visibility.rs
@@ -1,4 +1,3 @@
 pub(crate) struct S;
 pub(self) struct S;
-pub(self) struct S;
+pub(super) struct S;
-pub(self) struct S;
diff --git a/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast b/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
index d3219f0b2..c54e64e3f 100644
--- a/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
@@ -16,7 +16,8 @@ [email protected]
                [email protected] "must_use"
          [email protected] "]"
        [email protected] " "
-        [email protected] "self"
+        [email protected]
+          [email protected] "self"
      [email protected] ")"
    [email protected] " "
    [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rast b/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rast
new file mode 100644
index 000000000..3d855fc6b
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rast
@@ -0,0 +1,42 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected] "pub"
+      [email protected] "("
+      [email protected] "in"
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "super"
+        [email protected] "::"
+        [email protected]
+          [email protected]
+            [email protected] "A"
+      [email protected] ")"
+    [email protected] " "
+    [email protected] "struct"
+    [email protected] " "
+    [email protected]
+      [email protected] "S"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected]
+      [email protected] "pub"
+      [email protected] "("
+      [email protected] "in"
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "crate"
+      [email protected] ")"
+    [email protected] " "
+    [email protected] "struct"
+    [email protected] " "
+    [email protected]
+      [email protected] "S"
+    [email protected] ";"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rs b/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rs
new file mode 100644
index 000000000..2856dbd84
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0160_crate_visibility_in.rs
@@ -0,0 +1,2 @@
+pub(in super::A) struct S;
+pub(in crate) struct S;
diff --git a/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rast b/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rast
new file mode 100644
index 000000000..dcd39535b
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rast
@@ -0,0 +1,24 @@
+[email protected]
+  [email protected]
+    [email protected] "impl"
+    [email protected] " "
+    [email protected] "const"
+    [email protected] " "
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "Send"
+    [email protected] " "
+    [email protected] "for"
+    [email protected] " "
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "X"
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rs b/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rs
new file mode 100644
index 000000000..8d6886469
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0161_impl_def_const.rs
@@ -0,0 +1 @@
+impl const Send for X {}
diff --git a/crates/syntax/test_data/parser/ok/0007_extern_crate.rast b/crates/syntax/test_data/parser/ok/0007_extern_crate.rast
index 594c2f8f2..4babdba92 100644
--- a/crates/syntax/test_data/parser/ok/0007_extern_crate.rast
+++ b/crates/syntax/test_data/parser/ok/0007_extern_crate.rast
@@ -28,7 +28,8 @@ [email protected]
    [email protected] " "
    [email protected] "crate"
    [email protected] " "
-    [email protected] "self"
+    [email protected]
+      [email protected] "self"
    [email protected] " "
    [email protected]
      [email protected] "as"
diff --git a/crates/syntax/test_data/parser/ok/0012_visibility.rast b/crates/syntax/test_data/parser/ok/0012_visibility.rast
index 83a93b5a9..c5dbfb702 100644
--- a/crates/syntax/test_data/parser/ok/0012_visibility.rast
+++ b/crates/syntax/test_data/parser/ok/0012_visibility.rast
@@ -32,7 +32,10 @@ [email protected]
    [email protected]
      [email protected] "pub"
      [email protected] "("
-      [email protected] "crate"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "crate"
      [email protected] ")"
    [email protected] " "
    [email protected] "fn"
@@ -51,7 +54,10 @@ [email protected]
    [email protected]
      [email protected] "pub"
      [email protected] "("
-      [email protected] "super"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "super"
      [email protected] ")"
    [email protected] " "
    [email protected] "fn"
diff --git a/crates/syntax/test_data/parser/ok/0045_block_inner_attrs.rast b/crates/syntax/test_data/parser/ok/0045_block_inner_attrs.rast
index 0ac56df6d..6afed5f05 100644
--- a/crates/syntax/test_data/parser/ok/0045_block_inner_attrs.rast
+++ b/crates/syntax/test_data/parser/ok/0045_block_inner_attrs.rast
@@ -110,7 +110,8 @@ [email protected]
          [email protected] "("
          [email protected]
            [email protected] "&"
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ","
          [email protected] " "
          [email protected]
diff --git a/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast b/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
index 3fed11838..e10521d85 100644
--- a/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
+++ b/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
@@ -281,7 +281,8 @@ [email protected]
                    [email protected] "must_use"
              [email protected] "]"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -305,7 +306,8 @@ [email protected]
                    [email protected] "attr"
              [email protected] "]"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -330,7 +332,8 @@ [email protected]
              [email protected] "]"
            [email protected] " "
            [email protected] "&"
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -363,7 +366,8 @@ [email protected]
            [email protected] "&"
            [email protected] "mut"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -397,7 +401,8 @@ [email protected]
            [email protected]
              [email protected] "\'a"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -433,7 +438,8 @@ [email protected]
            [email protected] " "
            [email protected] "mut"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
          [email protected] ")"
        [email protected] " "
        [email protected]
@@ -457,7 +463,8 @@ [email protected]
                    [email protected] "attr"
              [email protected] "]"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
            [email protected] ":"
            [email protected] " "
            [email protected]
@@ -488,7 +495,8 @@ [email protected]
                    [email protected] "attr"
              [email protected] "]"
            [email protected] " "
-            [email protected] "self"
+            [email protected]
+              [email protected] "self"
            [email protected] ":"
            [email protected] " "
            [email protected]
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index e598c2c84..1edb7713d 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -294,6 +294,7 @@ async function getServer(config: Config, state: PersistentState): Promise<string
        "x64 linux": "x86_64-unknown-linux-gnu",
        "x64 darwin": "x86_64-apple-darwin",
        "arm64 win32": "aarch64-pc-windows-msvc",
+        "arm64 linux": "aarch64-unknown-linux-gnu",
        "arm64 darwin": "aarch64-apple-darwin",
    };
    const platform = platforms[`${process.arch} ${process.platform}`];
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 1bb9222d7..4abc7b053 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -15,7 +15,7 @@ flate2 = "1.0"
 pico-args = "0.3.1"
 proc-macro2 = "1.0.8"
 quote = "1.0.2"
-ungrammar = "1.8"
+ungrammar = "1.9"
 walkdir = "2.3.1"
 write-json = "0.1.0"
 xshell = "0.1"
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
index 046d68f52..0fd1d13e6 100644
--- a/xtask/src/ast_src.rs
+++ b/xtask/src/ast_src.rs
@@ -104,6 +104,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
        "MACRO_DEF",
        "PAREN_TYPE",
        "TUPLE_TYPE",
+        "MACRO_TYPE",
        "NEVER_TYPE",
        "PATH_TYPE",
        "PTR_TYPE",
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 12962bcfa..202c74426 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -67,6 +67,7 @@ pub struct ServerOpt {
 pub enum Malloc {
    System,
    Mimalloc,
+    Jemalloc,
 }
 impl InstallCmd {
@@ -176,6 +177,7 @@ fn install_server(opts: ServerOpt) -> Result<()> {
    let features = match opts.malloc {
        Malloc::System => &[][..],
        Malloc::Mimalloc => &["--features", "mimalloc"],
+        Malloc::Jemalloc => &["--features", "jemalloc"],
    };
    let cmd = cmd!("cargo install --path crates/rust-analyzer --locked --force {features...}");
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index dec48629c..c3e5c7326 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -49,7 +49,8 @@ FLAGS:
        --client[=CLIENT] Install only VS Code plugin.
                          CLIENT is one of 'code', 'code-exploration', 'code-insiders', 'codium', or 'code-oss'
        --server          Install only the language server
-        --mimalloc        Use mimalloc for server
+        --mimalloc        Use mimalloc allocator for server
+        --jemalloc        Use jemalloc allocator for server
    -h, --help            Prints help information
        "
                );
@@ -65,8 +66,13 @@ FLAGS:
                return Ok(());
            }
-            let malloc =
+            let malloc = if args.contains("--mimalloc") {
-                if args.contains("--mimalloc") { Malloc::Mimalloc } else { Malloc::System };
+                Malloc::Mimalloc
+            } else if args.contains("--jemalloc") {
+                Malloc::Jemalloc
+            } else {
+                Malloc::System
+            };
            let client_opt = args.opt_value_from_str("--client")?;