157 files changed, 3217 insertions, 1672 deletions
diff --git a/Cargo.lock b/Cargo.lock
index b52616974..bf1b9e417 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"
@@ -77,15 +77,15 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 [[package]]
 name = "backtrace"
-version = "0.3.55"
+version = "0.3.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef5140344c85b01f9bbb4d4b7288a8aa4b3287ccef913a14bcc78a1063623598"
+checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc"
 dependencies = [
 "addr2line",
 "cfg-if 1.0.0",
 "libc",
 "miniz_oxide",
- "object 0.22.0",
+ "object",
 "rustc-demangle",
 ]
@@ -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",
@@ -175,9 +175,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "chalk-derive"
-version = "0.47.0"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f00f6342a387edc822002d36a381e117afcac9f744951ff75fbf4a218edea5c"
+checksum = "ac605cf409013573e971d7292d4bec6f5495b19d5f98fc9d8b1a12270c3888e0"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -187,9 +187,9 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
-version = "0.47.0"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c686e69913591ae753e5526e73cbee39db3d9b0a92cc9078ab780cabf1c70aa9"
+checksum = "fa1dbfb3c2c8b67edb5cd981f720550e43579090574f786145731f90c5d401ff"
 dependencies = [
 "bitflags",
 "chalk-derive",
@@ -198,9 +198,9 @@ dependencies = [
 [[package]]
 name = "chalk-recursive"
-version = "0.47.0"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "310fdcac0340dab4163b766baa8067266e3b909108d1ac1b5246c033bde63975"
+checksum = "0882e2a3ba66901717a64f8bb0655e809f800ac6abed05cb605e7a41d4bf8999"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -211,9 +211,9 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
-version = "0.47.0"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3c3252116111c3548f1164ab8d98c67c49848b3bde10dd11b650fd023e91c72"
+checksum = "0d43cce07150eac39771ff4b198537cefef744734b2218a89c682295b54cd8d0"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -269,9 +269,20 @@ dependencies = [
 [[package]]
 name = "const_fn"
-version = "0.4.4"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28b9d6de7f49e22cf97ad17fc4036ece69300032f45f78f30b4a4482cdc3f4a6"
+[[package]]
+name = "countme"
+version = "2.0.0-pre.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd51eab21ab4fd6a3bf889e2d0958c0a6e3a61ad04260325e919e652a2a62826"
+checksum = "c5716604cba7c02a846ecad3f4a3fd2d2b641faccc2a24a51efb21aff0d01f35"
+dependencies = [
+ "dashmap",
+ "once_cell",
+ "rustc-hash",
+]
 [[package]]
 name = "crc32fast"
@@ -323,7 +334,7 @@ dependencies = [
 "const_fn",
 "crossbeam-utils 0.8.1",
 "lazy_static",
- "memoffset 0.6.1",
+ "memoffset",
 "scopeguard",
 ]
@@ -350,6 +361,16 @@ dependencies = [
 ]
 [[package]]
+name = "dashmap"
+version = "4.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e77a43b28d0668df09411cb0bc9a8c2adc40f9a048afe863e05fd43251e8e39c"
+dependencies = [
+ "cfg-if 1.0.0",
+ "num_cpus",
+]
+[[package]]
 name = "dissimilar"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -397,13 +418,13 @@ dependencies = [
 [[package]]
 name = "filetime"
-version = "0.2.13"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c122a393ea57648015bf06fbd3d372378992e86b9ff5a7a497b076a28c79efe"
+checksum = "1d34cfa13a63ae058bfa601fe9e313bbdb3746427c1459185464ce0fcf62e1e8"
 dependencies = [
 "cfg-if 1.0.0",
 "libc",
- "redox_syscall",
+ "redox_syscall 0.2.4",
 "winapi 0.3.9",
 ]
@@ -449,6 +470,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,12 +529,6 @@ 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"
@@ -518,9 +539,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",
 ]
@@ -692,7 +713,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
 dependencies = [
 "autocfg",
- "hashbrown 0.9.1",
+ "hashbrown",
 ]
 [[package]]
@@ -708,9 +729,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",
 ]
@@ -758,6 +779,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"
@@ -791,15 +844,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",
@@ -825,9 +878,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",
 ]
@@ -910,15 +963,6 @@ dependencies = [
 [[package]]
 name = "memoffset"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
-dependencies = [
- "autocfg",
-]
-[[package]]
-name = "memoffset"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "157b4208e3059a8f9e78d559edc658e13df41410cb3ae03979c83130067fdd87"
@@ -1050,12 +1094,6 @@ dependencies = [
 [[package]]
 name = "object"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
-[[package]]
-name = "object"
 version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"
@@ -1092,7 +1130,7 @@ dependencies = [
 "cfg-if 1.0.0",
 "instant",
 "libc",
- "redox_syscall",
+ "redox_syscall 0.1.57",
 "smallvec",
 "winapi 0.3.9",
 ]
@@ -1105,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,15 +1211,21 @@ dependencies = [
 [[package]]
 name = "pico-args"
-version = "0.3.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
+checksum = "d70072c20945e1ab871c472a285fc772aefd4f5407723c206242f2c6f94595d6"
 [[package]]
 name = "pin-project-lite"
-version = "0.2.0"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439697af366c49a6d0a010c56a0d97685bc140ce0d377b13a2ea2aa42d64a827"
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b063f57ec186e6140e2b8b6921e5f1bd89c7356dda5b33acc5401203ca6131c"
+checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
 [[package]]
 name = "proc-macro2"
@@ -1194,7 +1257,7 @@ dependencies = [
 "libloading",
 "mbe",
 "memmap",
- "object 0.23.0",
+ "object",
 "proc_macro_api",
 "proc_macro_test",
 "serde_derive",
@@ -1212,6 +1275,8 @@ name = "profile"
 version = "0.0.0"
 dependencies = [
 "cfg-if 1.0.0",
+ "countme",
+ "jemalloc-ctl",
 "la-arena",
 "libc",
 "once_cell",
@@ -1231,6 +1296,7 @@ dependencies = [
 "log",
 "paths",
 "proc_macro_api",
+ "profile",
 "rustc-hash",
 "serde",
 "serde_json",
@@ -1299,10 +1365,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 [[package]]
+name = "redox_syscall"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ec8ca9416c5ea37062b502703cd7fcb207736bc294f6e0cf367ac6fc234570"
+dependencies = [
+ "bitflags",
+]
+[[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",
 ]
@@ -1319,21 +1394,21 @@ 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.5"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1898adeafc7d3c69913b33ee1acbbb39c726a9dbe05ff77c08b52957643e8db"
+checksum = "24c2d78254049413f9d73495f883e7fa0b7a7d4b88468cd72a3bbbd0ad585cd1"
 dependencies = [
- "hashbrown 0.10.0",
+ "countme",
+ "hashbrown",
+ "memoffset",
 "rustc-hash",
- "smol_str",
 "text-size",
- "triomphe",
 ]
 [[package]]
@@ -1353,6 +1428,7 @@ dependencies = [
 "ide",
 "ide_db",
 "itertools 0.10.0",
+ "jemallocator",
 "jod-thread",
 "log",
 "lsp-server",
@@ -1388,9 +1464,9 @@ dependencies = [
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "697.0.0"
+version = "700.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67adbe260a0a11910624d6d28c0304fcf7b063e666682111005c83b09f73429d"
+checksum = "5ed36784376b69c941d7aa36e960a52ac712e2663960357121a4d9f2cc58e225"
 dependencies = [
 "unicode-xid",
 ]
@@ -1484,18 +1560,18 @@ dependencies = [
 [[package]]
 name = "serde"
-version = "1.0.118"
+version = "1.0.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800"
+checksum = "166b2349061381baf54a58e4b13c89369feb0ef2eaa57198899e2312aac30aab"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.118"
+version = "1.0.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df"
+checksum = "0ca2a8cb5805ce9e3b95435e3765b7b553cecc762d938d409434338386cb5775"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1551,9 +1627,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"
@@ -1579,12 +1655,6 @@ dependencies = [
 ]
 [[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-[[package]]
 name = "stdx"
 version = "0.0.0"
 dependencies = [
@@ -1593,9 +1663,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",
@@ -1672,9 +1742,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",
 ]
@@ -1812,17 +1882,6 @@ dependencies = [
 ]
 [[package]]
-name = "triomphe"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e9d872053cf9e5a833d8c1dd772cdc38ab66a908129d6f73c049c986161d07c"
-dependencies = [
- "memoffset 0.5.6",
- "serde",
- "stable_deref_trait",
-]
-[[package]]
 name = "tt"
 version = "0.0.0"
 dependencies = [
@@ -1838,9 +1897,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/generate_function.rs b/crates/assists/src/handlers/generate_function.rs
index 06ac85f67..1805c1dfd 100644
--- a/crates/assists/src/handlers/generate_function.rs
+++ b/crates/assists/src/handlers/generate_function.rs
@@ -158,11 +158,11 @@ impl FunctionBuilder {
                it.text_range().end()
            }
            GeneratedFunctionTarget::InEmptyItemList(it) => {
-                let indent = IndentLevel::from_node(it.syntax());
+                let indent = IndentLevel::from_node(&it);
                leading_ws = format!("\n{}", indent + 1);
                fn_def = fn_def.indent(indent + 1);
                trailing_ws = format!("\n{}", indent);
-                it.syntax().text_range().start() + TextSize::of('{')
+                it.text_range().start() + TextSize::of('{')
            }
        };
@@ -179,14 +179,14 @@ impl FunctionBuilder {
 enum GeneratedFunctionTarget {
    BehindItem(SyntaxNode),
-    InEmptyItemList(ast::ItemList),
+    InEmptyItemList(SyntaxNode),
 }
 impl GeneratedFunctionTarget {
    fn syntax(&self) -> &SyntaxNode {
        match self {
            GeneratedFunctionTarget::BehindItem(it) => it,
-            GeneratedFunctionTarget::InEmptyItemList(it) => it.syntax(),
+            GeneratedFunctionTarget::InEmptyItemList(it) => it,
        }
    }
 }
@@ -323,7 +323,16 @@ fn next_space_for_fn_in_module(
            if let Some(last_item) = it.item_list().and_then(|it| it.items().last()) {
                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
            } else {
-                GeneratedFunctionTarget::InEmptyItemList(it.item_list()?)
+                GeneratedFunctionTarget::InEmptyItemList(it.item_list()?.syntax().clone())
+            }
+        }
+        hir::ModuleSource::BlockExpr(it) => {
+            if let Some(last_item) =
+                it.statements().take_while(|stmt| matches!(stmt, ast::Stmt::Item(_))).last()
+            {
+                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
+            } else {
+                GeneratedFunctionTarget::InEmptyItemList(it.syntax().clone())
            }
        }
    };
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 9af45192b..827477272 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -1,6 +1,9 @@
 use itertools::Itertools;
 use stdx::format_to;
-use syntax::ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner};
+use syntax::{
+    ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner},
+    SmolStr,
+};
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -49,16 +52,16 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
                format_to!(buf, "{}", type_params.syntax());
            }
            buf.push_str(" ");
-            buf.push_str(name.text().as_str());
+            buf.push_str(name.text());
            if let Some(type_params) = type_params {
                let lifetime_params = type_params
                    .lifetime_params()
                    .filter_map(|it| it.lifetime())
-                    .map(|it| it.text().clone());
+                    .map(|it| SmolStr::from(it.text()));
                let type_params = type_params
                    .type_params()
                    .filter_map(|it| it.name())
-                    .map(|it| it.text().clone());
+                    .map(|it| SmolStr::from(it.text()));
                let generic_params = lifetime_params.chain(type_params).format(", ");
                format_to!(buf, "<{}>", generic_params)
diff --git a/crates/assists/src/handlers/generate_new.rs b/crates/assists/src/handlers/generate_new.rs
index 5c52b2bc8..b7390855a 100644
--- a/crates/assists/src/handlers/generate_new.rs
+++ b/crates/assists/src/handlers/generate_new.rs
@@ -3,7 +3,7 @@ use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
    ast::{self, AstNode, GenericParamsOwner, NameOwner, StructKind, VisibilityOwner},
-    T,
+    SmolStr, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -95,14 +95,14 @@ fn generate_impl_text(strukt: &ast::Struct, code: &str) -> String {
        format_to!(buf, "{}", type_params.syntax());
    }
    buf.push_str(" ");
-    buf.push_str(strukt.name().unwrap().text().as_str());
+    buf.push_str(strukt.name().unwrap().text());
    if let Some(type_params) = type_params {
        let lifetime_params = type_params
            .lifetime_params()
            .filter_map(|it| it.lifetime())
-            .map(|it| it.text().clone());
+            .map(|it| SmolStr::from(it.text()));
        let type_params =
-            type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
+            type_params.type_params().filter_map(|it| it.name()).map(|it| SmolStr::from(it.text()));
        format_to!(buf, "<{}>", lifetime_params.chain(type_params).format(", "))
    }
diff --git a/crates/assists/src/handlers/introduce_named_lifetime.rs b/crates/assists/src/handlers/introduce_named_lifetime.rs
index 3f5f44d69..02782eb6d 100644
--- a/crates/assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/assists/src/handlers/introduce_named_lifetime.rs
@@ -61,7 +61,7 @@ fn generate_fn_def_assist(
    // compute the location which implicitly has the same lifetime as the anonymous lifetime
    let loc_needing_lifetime = if let Some(self_param) = self_param {
        // if we have a self reference, use that
-        Some(self_param.self_token()?.text_range().start())
+        Some(self_param.name()?.syntax().text_range().start())
    } else {
        // otherwise, if there's a single reference parameter without a named liftime, use that
        let fn_params_without_lifetime: Vec<_> = param_list
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index a7d9fd4dc..b0b0d31b4 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,10 +1,7 @@
 use std::iter;
-use hir::AsName;
+use hir::{AsAssocItem, 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/assists/src/handlers/raw_string.rs b/crates/assists/src/handlers/raw_string.rs
index be963f162..d95267607 100644
--- a/crates/assists/src/handlers/raw_string.rs
+++ b/crates/assists/src/handlers/raw_string.rs
@@ -138,7 +138,7 @@ pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
        return None;
    }
-    let text = token.text().as_str();
+    let text = token.text();
    if !text.starts_with("r#") && text.ends_with('#') {
        return None;
    }
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index bd4c1c806..6aa9d2f2c 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -3,7 +3,7 @@ use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
    ast::{self, make, AstNode},
-    Direction, SmolStr,
+    Direction,
    SyntaxKind::{IDENT, WHITESPACE},
    TextSize,
 };
@@ -43,17 +43,18 @@ pub(crate) fn replace_derive_with_manual_impl(
 ) -> Option<()> {
    let attr = ctx.find_node_at_offset::<ast::Attr>()?;
-    let attr_name = attr
+    let has_derive = attr
        .syntax()
        .descendants_with_tokens()
        .filter(|t| t.kind() == IDENT)
        .find_map(syntax::NodeOrToken::into_token)
-        .filter(|t| t.text() == "derive")?
+        .filter(|t| t.text() == "derive")
-        .text()
+        .is_some();
-        .clone();
+    if !has_derive {
+        return None;
+    }
-    let trait_token =
+    let trait_token = ctx.token_at_offset().find(|t| t.kind() == IDENT && t.text() != "derive")?;
-        ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?;
    let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text())));
    let annotated_name = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?;
@@ -176,9 +177,9 @@ fn update_attribute(
        .syntax()
        .descendants_with_tokens()
        .filter(|t| t.kind() == IDENT)
-        .filter_map(|t| t.into_token().map(|t| t.text().clone()))
+        .filter_map(|t| t.into_token().map(|t| t.text().to_string()))
        .filter(|t| t != trait_name.text())
-        .collect::<Vec<SmolStr>>();
+        .collect::<Vec<_>>();
    let has_more_derives = !new_attr_input.is_empty();
    if has_more_derives {
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index fc9f83bab..44c35bafa 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -223,7 +223,7 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
            let method = mce.name_ref()?;
            let arg_list = mce.arg_list()?;
-            let method = match method.text().as_str() {
+            let method = match method.text() {
                "is_some" => "is_none",
                "is_none" => "is_some",
                "is_ok" => "is_err",
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 2dd8fbe67..b5f7e4200 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -178,7 +178,7 @@ pub struct CrateData {
    pub root_file_id: FileId,
    pub edition: Edition,
    /// A name used in the package's project declaration: for Cargo projects,
-    /// it's [package].name, can be different for other project types or even
+    /// its `[package].name` can be different for other project types or even
    /// absent (a dummy crate for the code snippet, for example).
    ///
    /// For purposes of analysis, crates are anonymous (only names in
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index e5522980d..ab25a8c58 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -99,13 +99,14 @@ const ATTRIBUTES: &[AttrCompletion] = &[
        Some("export_name"),
        Some(r#"export_name = "${0:exported_symbol_name}""#),
    ),
+    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
    attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
    attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
    // FIXME: resolve through macro resolution?
    attr("global_allocator", None, None).prefer_inner(),
    attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
-    attr("inline(…)", Some("inline"), Some("inline(${0:lint})")),
+    attr("inline", Some("inline"), Some("inline")),
    attr("link", None, None),
    attr(r#"link_name = "…""#, Some("link_name"), Some(r#"link_name = "${0:symbol_name}""#)),
    attr(
@@ -468,10 +469,11 @@ struct Test {}
                at deprecated
                at derive(…)
                at export_name = "…"
+                at doc(alias = "…")
                at doc = "…"
                at forbid(…)
                at ignore = "…"
-                at inline(…)
+                at inline
                at link
                at link_name = "…"
                at link_section = "…"
@@ -515,12 +517,13 @@ struct Test {}
                at deprecated
                at derive(…)
                at export_name = "…"
+                at doc(alias = "…")
                at doc = "…"
                at feature(…)
                at forbid(…)
                at global_allocator
                at ignore = "…"
-                at inline(…)
+                at inline
                at link
                at link_name = "…"
                at link_section = "…"
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index 222809638..dc0b38a16 100644
--- a/crates/completion/src/completions/flyimport.rs
+++ b/crates/completion/src/completions/flyimport.rs
@@ -20,11 +20,14 @@
 //! # pub mod std { pub mod marker { pub struct PhantomData { } } }
 //! ```
 //!
+//! Also completes associated items, that require trait imports.
+//!
 //! .Fuzzy search details
 //!
 //! To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
 //! (i.e. in `HashMap` in the `std::collections::HashMap` path).
-//! For the same reasons, avoids searching for any imports for inputs with their length less that 2 symbols.
+//! For the same reasons, avoids searching for any path imports for inputs with their length less that 2 symbols
+//! (but shows all associated items for any input length).
 //!
 //! .Import configuration
 //!
@@ -45,10 +48,12 @@
 //! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
 //! capability enabled.
-use either::Either;
+use hir::{AsAssocItem, ModPath, ScopeDef};
-use hir::{ModPath, ScopeDef};
+use ide_db::helpers::{
-use ide_db::{helpers::insert_use::ImportScope, imports_locator};
+    import_assets::{ImportAssets, ImportCandidate},
-use syntax::AstNode;
+    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,131 @@ fn main() {
            expect![[r#""#]],
        );
    }
+    #[test]
+    fn does_not_propose_traits_in_scope() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+//- /main.rs crate:main deps:dep
+use dep::test_mod::{TestStruct, TestTrait};
+fn main() {
+    dep::test_mod::TestStruct::hum$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+    #[test]
+    fn blanket_trait_impl_import() {
+        check_edit(
+            "another_function",
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub struct TestStruct {}
+    pub trait TestTrait {
+        fn another_function();
+    }
+    impl<T> TestTrait for T {
+        fn another_function() {}
+    }
+}
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::ano$0
+}
+"#,
+            r#"
+use dep::test_mod::TestTrait;
+fn main() {
+    dep::test_mod::TestStruct::another_function()$0
+}
+"#,
+        );
+    }
+    #[test]
+    fn zero_input_deprecated_assoc_item_completion() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.$0
+}
+        "#,
+            expect![[r#"
+                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self) DEPRECATED
+                "#]],
+        );
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::$0
+}
+"#,
+            expect![[r#"
+                ct SPECIAL_CONST (dep::test_mod::TestTrait) DEPRECATED
+                fn weird_function() (dep::test_mod::TestTrait) fn weird_function() DEPRECATED
+        "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index ac5596ca4..809e1645a 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -29,6 +29,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
    }
    ctx.scope.process_all_names(&mut |name, res| {
+        if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
+            mark::hit!(skip_lifetime_completion);
+            return;
+        }
        if ctx.use_item_syntax.is_some() {
            if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                if name_ref.syntax().text() == name.to_string().as_str() {
@@ -37,7 +41,7 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
                }
            }
        }
-        acc.add_resolution(ctx, name.to_string(), &res)
+        acc.add_resolution(ctx, name.to_string(), &res);
    });
 }
@@ -234,6 +238,24 @@ fn main() {
                fn quux() fn quux<T>()
            "#]],
        );
+        check(
+            r#"fn quux<const C: usize>() { $0 }"#,
+            expect![[r#"
+                tp C
+                fn quux() fn quux<const C: usize>()
+            "#]],
+        );
+    }
+    #[test]
+    fn does_not_complete_lifetimes() {
+        mark::check!(skip_lifetime_completion);
+        check(
+            r#"fn quux<'a>() { $0 }"#,
+            expect![[r#"
+                fn quux() fn quux<'a>()
+            "#]],
+        );
    }
    #[test]
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..4f622d28a 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -10,7 +10,9 @@ pub(crate) mod type_alias;
 mod builder_ext;
-use hir::{Documentation, HasAttrs, HirDisplay, Mutability, ScopeDef, Type};
+use hir::{
+    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
+};
 use ide_db::{helpers::SnippetCap, RootDatabase};
 use syntax::TextRange;
 use test_utils::mark;
@@ -51,16 +53,16 @@ pub(crate) fn render_resolution_with_import<'a>(
    import_edit: ImportEdit,
    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    Render::new(ctx)
+    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.
@@ -87,7 +89,24 @@ impl<'a> RenderContext<'a> {
    }
    fn is_deprecated(&self, node: impl HasAttrs) -> bool {
-        node.attrs(self.db()).by_key("deprecated").exists()
+        let attrs = node.attrs(self.db());
+        attrs.by_key("deprecated").exists() || attrs.by_key("rustc_deprecated").exists()
+    }
+    fn is_deprecated_assoc_item(&self, as_assoc_item: impl AsAssocItem) -> bool {
+        let db = self.db();
+        let assoc = match as_assoc_item.as_assoc_item(db) {
+            Some(assoc) => assoc,
+            None => return false,
+        };
+        let is_assoc_deprecated = match assoc {
+            hir::AssocItem::Function(it) => self.is_deprecated(it),
+            hir::AssocItem::Const(it) => self.is_deprecated(it),
+            hir::AssocItem::TypeAlias(it) => self.is_deprecated(it),
+        };
+        is_assoc_deprecated
+            || assoc.containing_trait(db).map(|trait_| self.is_deprecated(trait_)).unwrap_or(false)
    }
    fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
@@ -206,8 +225,6 @@ impl<'a> Render<'a> {
            }
        };
-        let docs = self.docs(resolution);
        let mut item =
            CompletionItem::new(completion_kind, self.ctx.source_range(), local_name.clone());
        if let ScopeDef::Local(local) = resolution {
@@ -253,13 +270,14 @@ impl<'a> Render<'a> {
            }
        }
-        let item = item
+        Some(
-            .kind(kind)
+            item.kind(kind)
-            .add_import(import_to_add)
+                .add_import(import_to_add)
-            .set_documentation(docs)
+                .set_ref_match(ref_match)
-            .set_ref_match(ref_match)
+                .set_documentation(self.docs(resolution))
-            .build();
+                .set_deprecated(self.is_deprecated(resolution))
-        Some(item)
+                .build(),
+        )
    }
    fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -275,6 +293,16 @@ impl<'a> Render<'a> {
            _ => None,
        }
    }
+    fn is_deprecated(&self, resolution: &ScopeDef) -> bool {
+        match resolution {
+            ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it),
+            ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it),
+            _ => false,
+        }
+    }
 }
 fn compute_score_from_active(
@@ -485,7 +513,7 @@ fn main() { let _: m::Spam = S$0 }
            r#"
 #[deprecated]
 fn something_deprecated() {}
-#[deprecated(since = "1.0.0")]
+#[rustc_deprecated(since = "1.0.0")]
 fn something_else_deprecated() {}
 fn main() { som$0 }
@@ -494,8 +522,8 @@ fn main() { som$0 }
                [
                    CompletionItem {
                        label: "main()",
-                        source_range: 121..124,
+                        source_range: 127..130,
-                        delete: 121..124,
+                        delete: 127..130,
                        insert: "main()$0",
                        kind: Function,
                        lookup: "main",
@@ -503,8 +531,8 @@ fn main() { som$0 }
                    },
                    CompletionItem {
                        label: "something_deprecated()",
-                        source_range: 121..124,
+                        source_range: 127..130,
-                        delete: 121..124,
+                        delete: 127..130,
                        insert: "something_deprecated()$0",
                        kind: Function,
                        lookup: "something_deprecated",
@@ -513,8 +541,8 @@ fn main() { som$0 }
                    },
                    CompletionItem {
                        label: "something_else_deprecated()",
-                        source_range: 121..124,
+                        source_range: 127..130,
-                        delete: 121..124,
+                        delete: 127..130,
                        insert: "something_else_deprecated()$0",
                        kind: Function,
                        lookup: "something_else_deprecated",
diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs
index ce924f309..e46452d4e 100644
--- a/crates/completion/src/render/const_.rs
+++ b/crates/completion/src/render/const_.rs
@@ -38,7 +38,10 @@ impl<'a> ConstRender<'a> {
        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
            .kind(CompletionItemKind::Const)
            .set_documentation(self.ctx.docs(self.const_))
-            .set_deprecated(self.ctx.is_deprecated(self.const_))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.const_)
+                    || self.ctx.is_deprecated_assoc_item(self.const_),
+            )
            .detail(detail)
            .build();
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index f5b0ce3e3..8f4c66211 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -44,7 +44,9 @@ impl<'a> FunctionRender<'a> {
        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
            .kind(self.kind())
            .set_documentation(self.ctx.docs(self.func))
-            .set_deprecated(self.ctx.is_deprecated(self.func))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
+            )
            .detail(self.detail())
            .add_call_parens(self.ctx.completion, self.name, params)
            .add_import(import_to_add)
diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs
index 69b445b9c..29287143a 100644
--- a/crates/completion/src/render/type_alias.rs
+++ b/crates/completion/src/render/type_alias.rs
@@ -38,7 +38,10 @@ impl<'a> TypeAliasRender<'a> {
        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
            .kind(CompletionItemKind::TypeAlias)
            .set_documentation(self.ctx.docs(self.type_alias))
-            .set_deprecated(self.ctx.is_deprecated(self.type_alias))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.type_alias)
+                    || self.ctx.is_deprecated_assoc_item(self.type_alias),
+            )
            .detail(detail)
            .build();
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index 6ea6da989..baff83305 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -18,7 +18,7 @@ use crate::{item::CompletionKind, CompletionConfig, CompletionItem};
 pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
    enable_postfix_completions: true,
-    enable_autoimport_completions: true,
+    enable_imports_on_the_fly: true,
    add_call_parenthesis: true,
    add_call_argument_snippets: true,
    snippet_cap: SnippetCap::new(true),
@@ -83,6 +83,9 @@ pub(crate) fn completion_list_with_config(
                let width = label_width.saturating_sub(monospace_width(it.label()));
                format_to!(buf, "{:width$} {}", "", detail, width = width);
            }
+            if it.deprecated() {
+                format_to!(buf, " DEPRECATED");
+            }
            format_to!(buf, "\n");
            buf
        })
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 99fb65bac..9e6a3e155 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -2,6 +2,7 @@
 use hir_def::{
    attr::{Attrs, Documentation},
    path::ModPath,
+    per_ns::PerNs,
    resolver::HasResolver,
    AttrDefId, GenericParamId, ModuleDefId,
 };
@@ -112,6 +113,11 @@ fn resolve_doc_path(
    let path = ast::Path::parse(link).ok()?;
    let modpath = ModPath::from_src(path, &Hygiene::new_unhygienic()).unwrap();
    let resolved = resolver.resolve_module_path_in_items(db.upcast(), &modpath);
+    if resolved == PerNs::none() {
+        if let Some(trait_id) = resolver.resolve_module_path_in_trait_items(db.upcast(), &modpath) {
+            return Some(ModuleDefId::TraitId(trait_id));
+        };
+    }
    let def = match ns {
        Some(Namespace::Types) => resolved.take_types()?,
        Some(Namespace::Values) => resolved.take_values()?,
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 6cbf5cecf..aaa7013b6 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -90,7 +90,7 @@ impl Crate {
    }
    pub fn root_module(self, db: &dyn HirDatabase) -> Module {
-        let module_id = db.crate_def_map(self.id).root;
+        let module_id = db.crate_def_map(self.id).root();
        Module::new(self, module_id)
    }
@@ -302,7 +302,7 @@ impl Module {
    /// in the module tree of any target in `Cargo.toml`.
    pub fn crate_root(self, db: &dyn HirDatabase) -> Module {
        let def_map = db.crate_def_map(self.id.krate);
-        self.with_module_id(def_map.root)
+        self.with_module_id(def_map.root())
    }
    /// Iterates over all child modules.
@@ -1000,7 +1000,7 @@ impl MacroDef {
    /// early, in `hir_expand`, where modules simply do not exist yet.
    pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
        let krate = self.id.krate;
-        let module_id = db.crate_def_map(krate).root;
+        let module_id = db.crate_def_map(krate).root();
        Some(Module::new(Crate { id: krate }, module_id))
    }
@@ -1051,6 +1051,16 @@ impl AsAssocItem for TypeAlias {
        as_assoc_item(db, AssocItem::TypeAlias, self.id)
    }
 }
+impl AsAssocItem for ModuleDef {
+    fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
+        match self {
+            ModuleDef::Function(it) => it.as_assoc_item(db),
+            ModuleDef::Const(it) => it.as_assoc_item(db),
+            ModuleDef::TypeAlias(it) => it.as_assoc_item(db),
+            _ => None,
+        }
+    }
+}
 fn as_assoc_item<ID, DEF, CTOR, AST>(db: &dyn HirDatabase, ctor: CTOR, id: ID) -> Option<AssocItem>
 where
    ID: Lookup<Data = AssocItemLoc<AST>>,
@@ -1091,6 +1101,13 @@ impl AssocItem {
            AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
        }
    }
+    pub fn containing_trait(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Trait(t) => Some(t),
+            _ => None,
+        }
+    }
 }
 impl HasVisibility for AssocItem {
@@ -2029,7 +2046,7 @@ impl Callable {
 pub enum ScopeDef {
    ModuleDef(ModuleDef),
    MacroDef(MacroDef),
-    GenericParam(TypeParam),
+    GenericParam(GenericParam),
    ImplSelfType(Impl),
    AdtSelfType(Adt),
    Local(Local),
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index d5d4cf5b6..d444f4bbb 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -1,13 +1,13 @@
 //! FIXME: write short doc here
 pub use hir_def::db::{
-    AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQueryQuery,
+    AttrsQuery, BlockDefMapQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery,
-    CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery, ExprScopesQuery,
+    CrateDefMapQueryQuery, CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery,
-    FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery, InternConstQuery,
+    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
-    InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
+    InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
-    InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery, InternUnionQuery,
+    InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
-    ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
+    InternUnionQuery, ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery,
-    TypeAliasDataQuery, UnionDataQuery,
+    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, HygieneFrameQuery, InternEagerExpansionQuery,
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index ab213e04c..0a30b4f5b 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -814,7 +814,7 @@ impl<'a> SemanticsScope<'a> {
                }
                resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
-                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
+                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(id.into()),
                resolver::ScopeDef::Local(pat_id) => {
                    let parent = resolver.body_owner().unwrap().into();
                    ScopeDef::Local(Local { parent, pat_id })
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 1b09ff816..c72649c41 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -207,6 +207,7 @@ impl Attrs {
                        mod_data.definition_source(db).as_ref().map(|src| match src {
                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
                            ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                            ModuleSource::BlockExpr(block) => block as &dyn AttrsOwner,
                        }),
                    ),
                }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 344f0b6c0..2c2c999dd 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -29,7 +29,7 @@ use crate::{
    expr::{Expr, ExprId, Label, LabelId, Pat, PatId},
    item_scope::BuiltinShadowMode,
    item_scope::ItemScope,
-    nameres::CrateDefMap,
+    nameres::DefMap,
    path::{ModPath, Path},
    src::HasSource,
    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
@@ -45,7 +45,7 @@ pub(crate) struct CfgExpander {
 pub(crate) struct Expander {
    cfg_expander: CfgExpander,
-    crate_def_map: Arc<CrateDefMap>,
+    crate_def_map: Arc<DefMap>,
    current_file_id: HirFileId,
    ast_id_map: Arc<AstIdMap>,
    module: ModuleId,
@@ -122,7 +122,7 @@ impl Expander {
        let mut err = None;
        let call_id =
-            macro_call.as_call_id_with_errors(db, self.crate_def_map.krate, resolver, &mut |e| {
+            macro_call.as_call_id_with_errors(db, self.crate_def_map.krate(), resolver, &mut |e| {
                err.get_or_insert(e);
            });
        let call_id = match call_id {
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index de77d5fc9..2e5d0a01e 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -6,18 +6,24 @@ use crate::{test_db::TestDB, ModuleDefId};
 use super::*;
 fn lower(ra_fixture: &str) -> Arc<Body> {
-    let (db, file_id) = crate::test_db::TestDB::with_single_file(ra_fixture);
+    let db = crate::test_db::TestDB::with_files(ra_fixture);
    let krate = db.crate_graph().iter().next().unwrap();
    let def_map = db.crate_def_map(krate);
-    let module = def_map.modules_for_file(file_id).next().unwrap();
+    let mut fn_def = None;
-    let module = &def_map[module];
+    'outer: for (_, module) in def_map.modules() {
-    let fn_def = match module.scope.declarations().next().unwrap() {
+        for decl in module.scope.declarations() {
-        ModuleDefId::FunctionId(it) => it,
+            match decl {
-        _ => panic!(),
+                ModuleDefId::FunctionId(it) => {
-    };
+                    fn_def = Some(it);
+                    break 'outer;
+                }
+                _ => {}
+            }
+        }
+    }
-    db.body(fn_def.into())
+    db.body(fn_def.unwrap().into())
 }
 fn check_diagnostics(ra_fixture: &str) {
@@ -42,6 +48,25 @@ fn main() { n_nuple!(1,2,3); }
 }
 #[test]
+fn macro_resolve() {
+    // Regression test for a path resolution bug introduced with inner item handling.
+    lower(
+        r"
+macro_rules! vec {
+    () => { () };
+    ($elem:expr; $n:expr) => { () };
+    ($($x:expr),+ $(,)?) => { () };
+}
+mod m {
+    fn outer() {
+        let _ = vec![FileSet::default(); self.len()];
+    }
+}
+      ",
+    );
+}
+#[test]
 fn cfg_diagnostics() {
    check_diagnostics(
        r"
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 6ef9fe790..a87c80b8a 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,9 @@
 use std::sync::Arc;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
-use hir_expand::{db::AstDatabase, HirFileId};
+use hir_expand::{db::AstDatabase, AstId, HirFileId};
 use la_arena::ArenaMap;
-use syntax::SmolStr;
+use syntax::{ast, SmolStr};
 use crate::{
    adt::{EnumData, StructData},
@@ -15,7 +15,7 @@ use crate::{
    import_map::ImportMap,
    item_tree::ItemTree,
    lang_item::{LangItemTarget, LangItems},
-    nameres::CrateDefMap,
+    nameres::DefMap,
    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
    GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
@@ -50,10 +50,13 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(crate_def_map_wait)]
    #[salsa::transparent]
-    fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
+    fn crate_def_map(&self, krate: CrateId) -> Arc<DefMap>;
-    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
+    #[salsa::invoke(DefMap::crate_def_map_query)]
-    fn crate_def_map_query(&self, krate: CrateId) -> Arc<CrateDefMap>;
+    fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
+    #[salsa::invoke(DefMap::block_def_map_query)]
+    fn block_def_map(&self, krate: CrateId, block: AstId<ast::BlockExpr>) -> Arc<DefMap>;
    #[salsa::invoke(StructData::struct_data_query)]
    fn struct_data(&self, id: StructId) -> Arc<StructData>;
@@ -112,7 +115,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    fn import_map(&self, krate: CrateId) -> Arc<ImportMap>;
 }
-fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
+fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<DefMap> {
    let _p = profile::span("crate_def_map:wait");
    db.crate_def_map_query(krate)
 }
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 4a212d291..db2d125ae 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -4,7 +4,7 @@ use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
-use crate::nameres::CrateDefMap;
+use crate::nameres::DefMap;
 use crate::{
    db::DefDatabase,
    item_scope::ItemInNs,
@@ -47,11 +47,11 @@ impl ModPath {
    }
 }
-fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+fn check_self_super(def_map: &DefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
    if item == ItemInNs::Types(from.into()) {
        // - if the item is the module we're in, use `self`
        Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
-    } else if let Some(parent_id) = def_map.modules[from.local_id].parent {
+    } else if let Some(parent_id) = def_map[from.local_id].parent {
        // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
        if item
            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
@@ -111,7 +111,7 @@ fn find_path_inner(
    // - if the item is already in scope, return the name under which it is
    let def_map = db.crate_def_map(from.krate);
-    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
+    let from_scope: &crate::item_scope::ItemScope = &def_map[from.local_id].scope;
    let scope_name =
        if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
    if prefixed.is_none() && scope_name.is_some() {
@@ -123,7 +123,7 @@ fn find_path_inner(
    if item
        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
            krate: from.krate,
-            local_id: def_map.root,
+            local_id: def_map.root(),
        }))
    {
        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
@@ -136,7 +136,7 @@ fn find_path_inner(
    }
    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
-    for (name, def_id) in &def_map.extern_prelude {
+    for (name, def_id) in def_map.extern_prelude() {
        if item == ItemInNs::Types(*def_id) {
            let name = scope_name.unwrap_or_else(|| name.clone());
            return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
@@ -144,10 +144,10 @@ fn find_path_inner(
    }
    // - if the item is in the prelude, return the name from there
-    if let Some(prelude_module) = def_map.prelude {
+    if let Some(prelude_module) = def_map.prelude() {
        let prelude_def_map = db.crate_def_map(prelude_module.krate);
        let prelude_scope: &crate::item_scope::ItemScope =
-            &prelude_def_map.modules[prelude_module.local_id].scope;
+            &prelude_def_map[prelude_module.local_id].scope;
        if let Some((name, vis)) = prelude_scope.name_of(item) {
            if vis.is_visible_from(db, from) {
                return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
@@ -175,7 +175,7 @@ fn find_path_inner(
    // - otherwise, look for modules containing (reexporting) it and import it from one of those
-    let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
+    let crate_root = ModuleId { local_id: def_map.root(), krate: from.krate };
    let crate_attrs = db.attrs(crate_root.into());
    let prefer_no_std = crate_attrs.by_key("no_std").exists();
    let mut best_path = None;
@@ -287,7 +287,7 @@ fn find_local_import_locations(
    // Compute the initial worklist. We start with all direct child modules of `from` as well as all
    // of its (recursive) parent modules.
-    let data = &def_map.modules[from.local_id];
+    let data = &def_map[from.local_id];
    let mut worklist = data
        .children
        .values()
@@ -296,7 +296,7 @@ fn find_local_import_locations(
    let mut parent = data.parent;
    while let Some(p) = parent {
        worklist.push(ModuleId { krate: from.krate, local_id: p });
-        parent = def_map.modules[p].parent;
+        parent = def_map[p].parent;
    }
    let mut seen: FxHashSet<_> = FxHashSet::default();
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index e5368b293..0251d016b 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -75,7 +75,7 @@ impl ImportMap {
        // We look only into modules that are public(ly reexported), starting with the crate root.
        let empty = ImportPath { segments: vec![] };
-        let root = ModuleId { krate, local_id: def_map.root };
+        let root = ModuleId { krate, local_id: def_map.root() };
        let mut worklist = vec![(root, empty)];
        while let Some((module, mod_path)) = worklist.pop() {
            let ext_def_map;
@@ -263,6 +263,7 @@ pub enum ImportKind {
    Trait,
    TypeAlias,
    BuiltinType,
+    AssociatedItem,
 }
 /// A way to match import map contents against the search query.
@@ -282,6 +283,7 @@ pub struct Query {
    query: String,
    lowercased: String,
    name_only: bool,
+    assoc_items_only: bool,
    search_mode: SearchMode,
    case_sensitive: bool,
    limit: usize,
@@ -295,6 +297,7 @@ impl Query {
            query,
            lowercased,
            name_only: false,
+            assoc_items_only: false,
            search_mode: SearchMode::Contains,
            case_sensitive: false,
            limit: usize::max_value(),
@@ -309,6 +312,11 @@ impl Query {
        Self { name_only: true, ..self }
    }
+    /// Matches only the entries that are associated items, ignoring the rest.
+    pub fn assoc_items_only(self) -> Self {
+        Self { assoc_items_only: true, ..self }
+    }
    /// Specifies the way to search for the entries using the query.
    pub fn search_mode(self, search_mode: SearchMode) -> Self {
        Self { search_mode, ..self }
@@ -331,6 +339,14 @@ impl Query {
    }
    fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {
+        if import.is_trait_assoc_item {
+            if self.exclude_import_kinds.contains(&ImportKind::AssociatedItem) {
+                return false;
+            }
+        } else if self.assoc_items_only {
+            return false;
+        }
        let mut input = if import.is_trait_assoc_item || self.name_only {
            import.path.segments.last().unwrap().to_string()
        } else {
@@ -814,6 +830,56 @@ mod tests {
    }
    #[test]
+    fn assoc_items_filtering() {
+        let ra_fixture = r#"
+        //- /main.rs crate:main deps:dep
+        //- /dep.rs crate:dep
+        pub mod fmt {
+            pub trait Display {
+                type FmtTypeAlias;
+                const FMT_CONST: bool;
+                fn format_function();
+                fn format_method(&self);
+            }
+        }
+    "#;
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).search_mode(SearchMode::Fuzzy).assoc_items_only(),
+            expect![[r#"
+            dep::fmt::Display::FMT_CONST (a)
+            dep::fmt::Display::format_function (a)
+            dep::fmt::Display::format_method (a)
+        "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string())
+                .search_mode(SearchMode::Fuzzy)
+                .exclude_import_kind(ImportKind::AssociatedItem),
+            expect![[r#"
+            dep::fmt (t)
+            dep::fmt::Display (t)
+        "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string())
+                .search_mode(SearchMode::Fuzzy)
+                .assoc_items_only()
+                .exclude_import_kind(ImportKind::AssociatedItem),
+            expect![[r#""#]],
+        );
+    }
+    #[test]
    fn search_mode() {
        let ra_fixture = r#"
            //- /main.rs crate:main deps:dep
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 9a433b61c..b8d7608e7 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -21,6 +21,7 @@ use hir_expand::{
    HirFileId, InFile,
 };
 use la_arena::{Arena, Idx, RawIdx};
+use profile::Count;
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
 use syntax::{ast, match_ast};
@@ -67,15 +68,16 @@ impl GenericParamsId {
 /// The item tree of a source file.
 #[derive(Debug, Eq, PartialEq)]
 pub struct ItemTree {
+    _c: Count<Self>,
    top_level: SmallVec<[ModItem; 1]>,
    attrs: FxHashMap<AttrOwner, RawAttrs>,
-    inner_items: FxHashMap<FileAstId<ast::Item>, SmallVec<[ModItem; 1]>>,
    data: Option<Box<ItemTreeData>>,
 }
 impl ItemTree {
-    pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+    pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
        let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
        let syntax = if let Some(node) = db.parse_or_expand(file_id) {
            node
@@ -118,9 +120,9 @@ impl ItemTree {
    fn empty() -> Self {
        Self {
+            _c: Count::new(),
            top_level: Default::default(),
            attrs: Default::default(),
-            inner_items: Default::default(),
            data: Default::default(),
        }
    }
@@ -145,9 +147,9 @@ impl ItemTree {
                macro_calls,
                macro_rules,
                macro_defs,
-                exprs,
                vis,
                generics,
+                inner_items,
            } = &mut **data;
            imports.shrink_to_fit();
@@ -167,10 +169,11 @@ 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();
+            inner_items.shrink_to_fit();
        }
    }
@@ -193,16 +196,18 @@ impl ItemTree {
        self.raw_attrs(of).clone().filter(db, krate)
    }
-    /// Returns the lowered inner items that `ast` corresponds to.
+    pub fn all_inner_items(&self) -> impl Iterator<Item = ModItem> + '_ {
-    ///
+        match &self.data {
-    /// Most AST items are lowered to a single `ModItem`, but some (eg. `use` items) may be lowered
+            Some(data) => Some(data.inner_items.values().flatten().copied()).into_iter().flatten(),
-    /// to multiple items in the `ItemTree`.
+            None => None.into_iter().flatten(),
-    pub fn inner_items(&self, ast: FileAstId<ast::Item>) -> &[ModItem] {
+        }
-        &self.inner_items[&ast]
    }
-    pub fn all_inner_items(&self) -> impl Iterator<Item = ModItem> + '_ {
+    pub fn inner_items_of_block(&self, block: FileAstId<ast::BlockExpr>) -> &[ModItem] {
-        self.inner_items.values().flatten().copied()
+        match &self.data {
+            Some(data) => data.inner_items.get(&block).map(|it| &**it).unwrap_or(&[]),
+            None => &[],
+        }
    }
    pub fn source<S: ItemTreeNode>(&self, db: &dyn DefDatabase, of: ItemTreeId<S>) -> S::Source {
@@ -296,10 +301,11 @@ struct ItemTreeData {
    macro_calls: Arena<MacroCall>,
    macro_rules: Arena<MacroRules>,
    macro_defs: Arena<MacroDef>,
-    exprs: Arena<Expr>,
    vis: ItemVisibilities,
    generics: GenericParamsStorage,
+    inner_items: FxHashMap<FileAstId<ast::BlockExpr>, SmallVec<[ModItem; 1]>>,
 }
 #[derive(Debug, Eq, PartialEq, Hash)]
@@ -461,7 +467,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 +670,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/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 5e71ca42c..ce470fc3b 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -6,7 +6,7 @@ use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId}
 use smallvec::SmallVec;
 use syntax::{
    ast::{self, ModuleItemOwner},
-    SyntaxNode,
+    SyntaxNode, WalkEvent,
 };
 use crate::{
@@ -37,7 +37,6 @@ pub(super) struct Ctx {
    file: HirFileId,
    source_ast_id_map: Arc<AstIdMap>,
    body_ctx: crate::body::LowerCtx,
-    inner_items: Vec<ModItem>,
    forced_visibility: Option<RawVisibilityId>,
 }
@@ -49,7 +48,6 @@ impl Ctx {
            file,
            source_ast_id_map: db.ast_id_map(file),
            body_ctx: crate::body::LowerCtx::new(db, file),
-            inner_items: Vec::new(),
            forced_visibility: None,
        }
    }
@@ -73,8 +71,6 @@ impl Ctx {
    }
    fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItems> {
-        assert!(inner || self.inner_items.is_empty());
        // Collect inner items for 1-to-1-lowered items.
        match item {
            ast::Item::Struct(_)
@@ -150,14 +146,37 @@ impl Ctx {
    fn collect_inner_items(&mut self, container: &SyntaxNode) {
        let forced_vis = self.forced_visibility.take();
-        let mut inner_items = mem::take(&mut self.tree.inner_items);
-        inner_items.extend(container.descendants().skip(1).filter_map(ast::Item::cast).filter_map(
+        let mut block_stack = Vec::new();
-            |item| {
+        for event in container.preorder().skip(1) {
-                let ast_id = self.source_ast_id_map.ast_id(&item);
+            match event {
-                Some((ast_id, self.lower_mod_item(&item, true)?.0))
+                WalkEvent::Enter(node) => {
-            },
+                    match_ast! {
-        ));
+                        match node {
-        self.tree.inner_items = inner_items;
+                            ast::BlockExpr(block) => {
+                                block_stack.push(self.source_ast_id_map.ast_id(&block));
+                            },
+                            ast::Item(item) => {
+                                let mod_items = self.lower_mod_item(&item, true);
+                                let current_block = block_stack.last();
+                                if let (Some(mod_items), Some(block)) = (mod_items, current_block) {
+                                    if !mod_items.0.is_empty() {
+                                        self.data().inner_items.entry(*block).or_default().extend(mod_items.0.iter().copied());
+                                    }
+                                }
+                            },
+                            _ => {}
+                        }
+                    }
+                }
+                WalkEvent::Leave(node) => {
+                    if ast::BlockExpr::cast(node).is_some() {
+                        block_stack.pop();
+                    }
+                }
+            }
+        }
        self.forced_visibility = forced_vis;
    }
diff --git a/crates/hir_def/src/lang_item.rs b/crates/hir_def/src/lang_item.rs
index 30188b740..9e90f745c 100644
--- a/crates/hir_def/src/lang_item.rs
+++ b/crates/hir_def/src/lang_item.rs
@@ -84,7 +84,7 @@ impl LangItems {
        let crate_def_map = db.crate_def_map(krate);
-        for (_, module_data) in crate_def_map.modules.iter() {
+        for (_, module_data) in crate_def_map.modules() {
            for impl_def in module_data.scope.impls() {
                lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
            }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 50acc3f54..bd3ea9b8b 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -59,9 +59,10 @@ use std::sync::Arc;
 use base_db::{CrateId, Edition, FileId};
 use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile};
 use la_arena::Arena;
+use profile::Count;
 use rustc_hash::FxHashMap;
 use stdx::format_to;
-use syntax::ast;
+use syntax::{ast, AstNode};
 use crate::{
    db::DefDatabase,
@@ -74,21 +75,23 @@ use crate::{
 /// Contains all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
-pub struct CrateDefMap {
+pub struct DefMap {
-    pub root: LocalModuleId,
+    _c: Count<Self>,
-    pub modules: Arena<ModuleData>,
+    parent: Option<Arc<DefMap>>,
-    pub(crate) krate: CrateId,
+    root: LocalModuleId,
+    modules: Arena<ModuleData>,
+    krate: CrateId,
    /// The prelude module for this crate. This either comes from an import
    /// marked with the `prelude_import` attribute, or (in the normal case) from
    /// a dependency (`std` or `core`).
-    pub(crate) prelude: Option<ModuleId>,
+    prelude: Option<ModuleId>,
-    pub(crate) extern_prelude: FxHashMap<Name, ModuleDefId>,
+    extern_prelude: FxHashMap<Name, ModuleDefId>,
    edition: Edition,
    diagnostics: Vec<DefDiagnostic>,
 }
-impl std::ops::Index<LocalModuleId> for CrateDefMap {
+impl std::ops::Index<LocalModuleId> for DefMap {
    type Output = ModuleData;
    fn index(&self, id: LocalModuleId) -> &ModuleData {
        &self.modules[id]
@@ -109,6 +112,10 @@ pub enum ModuleOrigin {
    Inline {
        definition: AstId<ast::Module>,
    },
+    /// Pseudo-module introduced by a block scope (contains only inner items).
+    BlockExpr {
+        block: AstId<ast::BlockExpr>,
+    },
 }
 impl Default for ModuleOrigin {
@@ -122,7 +129,7 @@ impl ModuleOrigin {
        match self {
            ModuleOrigin::File { declaration: module, .. }
            | ModuleOrigin::Inline { definition: module, .. } => Some(*module),
-            ModuleOrigin::CrateRoot { .. } => None,
+            ModuleOrigin::CrateRoot { .. } | ModuleOrigin::BlockExpr { .. } => None,
        }
    }
@@ -137,7 +144,7 @@ impl ModuleOrigin {
    pub fn is_inline(&self) -> bool {
        match self {
-            ModuleOrigin::Inline { .. } => true,
+            ModuleOrigin::Inline { .. } | ModuleOrigin::BlockExpr { .. } => true,
            ModuleOrigin::CrateRoot { .. } | ModuleOrigin::File { .. } => false,
        }
    }
@@ -155,6 +162,9 @@ impl ModuleOrigin {
                definition.file_id,
                ModuleSource::Module(definition.to_node(db.upcast())),
            ),
+            ModuleOrigin::BlockExpr { block } => {
+                InFile::new(block.file_id, ModuleSource::BlockExpr(block.to_node(db.upcast())))
+            }
        }
    }
 }
@@ -169,29 +179,56 @@ pub struct ModuleData {
    pub origin: ModuleOrigin,
 }
-impl CrateDefMap {
+impl DefMap {
-    pub(crate) fn crate_def_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
+    pub(crate) fn crate_def_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<DefMap> {
        let _p = profile::span("crate_def_map_query").detail(|| {
            db.crate_graph()[krate].display_name.as_deref().unwrap_or_default().to_string()
        });
-        let def_map = {
+        let edition = db.crate_graph()[krate].edition;
-            let edition = db.crate_graph()[krate].edition;
+        let def_map = DefMap::empty(krate, edition);
-            let mut modules: Arena<ModuleData> = Arena::default();
+        let def_map = collector::collect_defs(db, def_map, None);
-            let root = modules.alloc(ModuleData::default());
-            CrateDefMap {
-                krate,
-                edition,
-                extern_prelude: FxHashMap::default(),
-                prelude: None,
-                root,
-                modules,
-                diagnostics: Vec::new(),
-            }
-        };
-        let def_map = collector::collect_defs(db, def_map);
        Arc::new(def_map)
    }
+    pub(crate) fn block_def_map_query(
+        db: &dyn DefDatabase,
+        krate: CrateId,
+        block: AstId<ast::BlockExpr>,
+    ) -> Arc<DefMap> {
+        let item_tree = db.item_tree(block.file_id);
+        let block_items = item_tree.inner_items_of_block(block.value);
+        let parent = parent_def_map(db, krate, block);
+        if block_items.is_empty() {
+            // If there are no inner items, nothing new is brought into scope, so we can just return
+            // the parent DefMap. This keeps DefMap parent chains short.
+            return parent;
+        }
+        let mut def_map = DefMap::empty(krate, parent.edition);
+        def_map.parent = Some(parent);
+        let def_map = collector::collect_defs(db, def_map, Some(block.value));
+        Arc::new(def_map)
+    }
+    fn empty(krate: CrateId, edition: Edition) -> DefMap {
+        let mut modules: Arena<ModuleData> = Arena::default();
+        let root = modules.alloc(ModuleData::default());
+        DefMap {
+            _c: Count::new(),
+            parent: None,
+            krate,
+            edition,
+            extern_prelude: FxHashMap::default(),
+            prelude: None,
+            root,
+            modules,
+            diagnostics: Vec::new(),
+        }
+    }
    pub fn add_diagnostics(
        &self,
        db: &dyn DefDatabase,
@@ -208,6 +245,26 @@ impl CrateDefMap {
            .map(|(id, _data)| id)
    }
+    pub fn modules(&self) -> impl Iterator<Item = (LocalModuleId, &ModuleData)> + '_ {
+        self.modules.iter()
+    }
+    pub fn root(&self) -> LocalModuleId {
+        self.root
+    }
+    pub(crate) fn krate(&self) -> CrateId {
+        self.krate
+    }
+    pub(crate) fn prelude(&self) -> Option<ModuleId> {
+        self.prelude
+    }
+    pub(crate) fn extern_prelude(&self) -> impl Iterator<Item = (&Name, &ModuleDefId)> + '_ {
+        self.extern_prelude.iter()
+    }
    pub(crate) fn resolve_path(
        &self,
        db: &dyn DefDatabase,
@@ -224,10 +281,15 @@ impl CrateDefMap {
    // even), as this should be a great debugging aid.
    pub fn dump(&self) -> String {
        let mut buf = String::new();
-        go(&mut buf, self, "crate", self.root);
+        let mut current_map = self;
+        while let Some(parent) = &current_map.parent {
+            go(&mut buf, current_map, "block scope", current_map.root);
+            current_map = &**parent;
+        }
+        go(&mut buf, current_map, "crate", current_map.root);
        return buf;
-        fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
+        fn go(buf: &mut String, map: &DefMap, path: &str, module: LocalModuleId) {
            format_to!(buf, "{}\n", path);
            let mut entries: Vec<_> = map.modules[module].scope.resolutions().collect();
@@ -276,10 +338,40 @@ impl ModuleData {
    }
 }
+fn parent_def_map(
+    db: &dyn DefDatabase,
+    krate: CrateId,
+    block: AstId<ast::BlockExpr>,
+) -> Arc<DefMap> {
+    // FIXME: store this info in the item tree instead of reparsing here
+    let ast_id_map = db.ast_id_map(block.file_id);
+    let block_ptr = ast_id_map.get(block.value);
+    let root = match db.parse_or_expand(block.file_id) {
+        Some(it) => it,
+        None => {
+            return Arc::new(DefMap::empty(krate, Edition::Edition2018));
+        }
+    };
+    let ast = block_ptr.to_node(&root);
+    for ancestor in ast.syntax().ancestors().skip(1) {
+        if let Some(block_expr) = ast::BlockExpr::cast(ancestor) {
+            let ancestor_id = ast_id_map.ast_id(&block_expr);
+            let ast_id = InFile::new(block.file_id, ancestor_id);
+            let parent_map = db.block_def_map(krate, ast_id);
+            return parent_map;
+        }
+    }
+    // No enclosing block scope, so the parent is the crate-level DefMap.
+    db.crate_def_map(krate)
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ModuleSource {
    SourceFile(ast::SourceFile),
    Module(ast::Module),
+    BlockExpr(ast::BlockExpr),
 }
 mod diagnostics {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 0cd61698c..cd68efbe6 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -31,7 +31,7 @@ use crate::{
    },
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
-        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
+        BuiltinShadowMode, DefMap, ModuleData, ModuleOrigin, ResolveMode,
    },
    path::{ImportAlias, ModPath, PathKind},
    per_ns::PerNs,
@@ -45,7 +45,11 @@ const GLOB_RECURSION_LIMIT: usize = 100;
 const EXPANSION_DEPTH_LIMIT: usize = 128;
 const FIXED_POINT_LIMIT: usize = 8192;
-pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
+pub(super) fn collect_defs(
+    db: &dyn DefDatabase,
+    mut def_map: DefMap,
+    block: Option<FileAstId<ast::BlockExpr>>,
+) -> DefMap {
    let crate_graph = db.crate_graph();
    // populate external prelude
@@ -93,6 +97,14 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
        exports_proc_macros: false,
        from_glob_import: Default::default(),
    };
+    match block {
+        Some(block) => {
+            collector.seed_with_inner(block);
+        }
+        None => {
+            collector.seed_with_top_level();
+        }
+    }
    collector.collect();
    collector.finish()
 }
@@ -210,7 +222,7 @@ struct DefData<'a> {
 /// Walks the tree of module recursively
 struct DefCollector<'a> {
    db: &'a dyn DefDatabase,
-    def_map: CrateDefMap,
+    def_map: DefMap,
    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility)>>,
    unresolved_imports: Vec<ImportDirective>,
    resolved_imports: Vec<ImportDirective>,
@@ -228,7 +240,7 @@ struct DefCollector<'a> {
 }
 impl DefCollector<'_> {
-    fn collect(&mut self) {
+    fn seed_with_top_level(&mut self) {
        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
        let item_tree = self.db.item_tree(file_id.into());
        let module_id = self.def_map.root;
@@ -248,7 +260,31 @@ impl DefCollector<'_> {
            }
            .collect(item_tree.top_level_items());
        }
+    }
+    fn seed_with_inner(&mut self, block: FileAstId<ast::BlockExpr>) {
+        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
+        let item_tree = self.db.item_tree(file_id.into());
+        let module_id = self.def_map.root;
+        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
+        if item_tree
+            .top_level_attrs(self.db, self.def_map.krate)
+            .cfg()
+            .map_or(true, |cfg| self.cfg_options.check(&cfg) != Some(false))
+        {
+            ModCollector {
+                def_collector: &mut *self,
+                macro_depth: 0,
+                module_id,
+                file_id: file_id.into(),
+                item_tree: &item_tree,
+                mod_dir: ModDir::root(),
+            }
+            .collect(item_tree.inner_items_of_block(block));
+        }
+    }
+    fn collect(&mut self) {
        // main name resolution fixed-point loop.
        let mut i = 0;
        loop {
@@ -859,7 +895,7 @@ impl DefCollector<'_> {
        .collect(item_tree.top_level_items());
    }
-    fn finish(mut self) -> CrateDefMap {
+    fn finish(mut self) -> DefMap {
        // Emit diagnostics for all remaining unexpanded macros.
        for directive in &self.unexpanded_macros {
@@ -1470,11 +1506,10 @@ impl ModCollector<'_, '_> {
 mod tests {
    use crate::{db::DefDatabase, test_db::TestDB};
    use base_db::{fixture::WithFixture, SourceDatabase};
-    use la_arena::Arena;
    use super::*;
-    fn do_collect_defs(db: &dyn DefDatabase, def_map: CrateDefMap) -> CrateDefMap {
+    fn do_collect_defs(db: &dyn DefDatabase, def_map: DefMap) -> DefMap {
        let mut collector = DefCollector {
            db,
            def_map,
@@ -1489,28 +1524,17 @@ mod tests {
            exports_proc_macros: false,
            from_glob_import: Default::default(),
        };
+        collector.seed_with_top_level();
        collector.collect();
        collector.def_map
    }
-    fn do_resolve(code: &str) -> CrateDefMap {
+    fn do_resolve(code: &str) -> DefMap {
        let (db, _file_id) = TestDB::with_single_file(&code);
        let krate = db.test_crate();
-        let def_map = {
+        let edition = db.crate_graph()[krate].edition;
-            let edition = db.crate_graph()[krate].edition;
+        let def_map = DefMap::empty(krate, edition);
-            let mut modules: Arena<ModuleData> = Arena::default();
-            let root = modules.alloc(ModuleData::default());
-            CrateDefMap {
-                krate,
-                edition,
-                extern_prelude: FxHashMap::default(),
-                prelude: None,
-                root,
-                modules,
-                diagnostics: Vec::new(),
-            }
-        };
        do_collect_defs(&db, def_map)
    }
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 88e10574e..ec90f4e65 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -19,7 +19,7 @@ use test_utils::mark;
 use crate::{
    db::DefDatabase,
    item_scope::BUILTIN_SCOPE,
-    nameres::{BuiltinShadowMode, CrateDefMap},
+    nameres::{BuiltinShadowMode, DefMap},
    path::{ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
@@ -61,7 +61,7 @@ impl ResolvePathResult {
    }
 }
-impl CrateDefMap {
+impl DefMap {
    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
        self.extern_prelude
            .get(name)
@@ -104,6 +104,43 @@ impl CrateDefMap {
        path: &ModPath,
        shadow: BuiltinShadowMode,
    ) -> ResolvePathResult {
+        let mut result = ResolvePathResult::empty(ReachedFixedPoint::No);
+        result.segment_index = Some(usize::max_value());
+        let mut current_map = self;
+        loop {
+            let new = current_map.resolve_path_fp_with_macro_single(
+                db,
+                mode,
+                original_module,
+                path,
+                shadow,
+            );
+            // Merge `new` into `result`.
+            result.resolved_def = result.resolved_def.or(new.resolved_def);
+            if result.reached_fixedpoint == ReachedFixedPoint::No {
+                result.reached_fixedpoint = new.reached_fixedpoint;
+            }
+            // FIXME: this doesn't seem right; what if the different namespace resolutions come from different crates?
+            result.krate = result.krate.or(new.krate);
+            result.segment_index = result.segment_index.min(new.segment_index);
+            match &current_map.parent {
+                Some(map) => current_map = map,
+                None => return result,
+            }
+        }
+    }
+    pub(super) fn resolve_path_fp_with_macro_single(
+        &self,
+        db: &dyn DefDatabase,
+        mode: ResolveMode,
+        original_module: LocalModuleId,
+        path: &ModPath,
+        shadow: BuiltinShadowMode,
+    ) -> ResolvePathResult {
        let mut segments = path.segments.iter().enumerate();
        let mut curr_per_ns: PerNs = match path.kind {
            PathKind::DollarCrate(krate) => {
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index c459fa66d..73e3a4702 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -4,27 +4,47 @@ mod macros;
 mod mod_resolution;
 mod diagnostics;
 mod primitives;
+mod block;
 use std::sync::Arc;
 use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::{expect, Expect};
+use hir_expand::db::AstDatabase;
 use test_utils::mark;
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
-fn compute_crate_def_map(ra_fixture: &str) -> Arc<CrateDefMap> {
+fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
    let db = TestDB::with_files(ra_fixture);
    let krate = db.crate_graph().iter().next().unwrap();
    db.crate_def_map(krate)
 }
+fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
+    let (db, position) = TestDB::with_position(ra_fixture);
+    let module = db.module_for_file(position.file_id);
+    let ast_map = db.ast_id_map(position.file_id.into());
+    let ast = db.parse(position.file_id);
+    let block: ast::BlockExpr =
+        syntax::algo::find_node_at_offset(&ast.syntax_node(), position.offset).unwrap();
+    let block_id = ast_map.ast_id(&block);
+    db.block_def_map(module.krate, InFile::new(position.file_id.into(), block_id))
+}
 fn check(ra_fixture: &str, expect: Expect) {
    let def_map = compute_crate_def_map(ra_fixture);
    let actual = def_map.dump();
    expect.assert_eq(&actual);
 }
+fn check_at(ra_fixture: &str, expect: Expect) {
+    let def_map = compute_block_def_map(ra_fixture);
+    let actual = def_map.dump();
+    expect.assert_eq(&actual);
+}
 #[test]
 fn crate_def_map_smoke_test() {
    check(
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
new file mode 100644
index 000000000..01d6326a7
--- /dev/null
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -0,0 +1,97 @@
+use super::*;
+#[test]
+fn inner_item_smoke() {
+    check_at(
+        r#"
+struct inner {}
+fn outer() {
+    $0
+    fn inner() {}
+}
+"#,
+        expect![[r#"
+            block scope
+            inner: v
+            crate
+            inner: t
+            outer: v
+        "#]],
+    );
+}
+#[test]
+fn use_from_crate() {
+    check_at(
+        r#"
+struct Struct;
+fn outer() {
+    use Struct;
+    use crate::Struct as CrateStruct;
+    use self::Struct as SelfStruct;
+    $0
+}
+"#,
+        expect![[r#"
+            block scope
+            CrateStruct: t v
+            SelfStruct: t v
+            Struct: t v
+            crate
+            Struct: t v
+            outer: v
+        "#]],
+    );
+}
+#[test]
+fn merge_namespaces() {
+    check_at(
+        r#"
+struct name {}
+fn outer() {
+    fn name() {}
+    use name as imported; // should import both `name`s
+    $0
+}
+"#,
+        expect![[r#"
+            block scope
+            imported: t v
+            name: v
+            crate
+            name: t
+            outer: v
+        "#]],
+    );
+}
+#[test]
+fn nested_blocks() {
+    check_at(
+        r#"
+fn outer() {
+    struct inner1 {}
+    fn inner() {
+        use inner1;
+        use outer;
+        fn inner2() {}
+        $0
+    }
+}
+"#,
+        expect![[r#"
+            block scope
+            inner1: t
+            inner2: v
+            outer: v
+            block scope
+            inner: v
+            inner1: t
+            crate
+            outer: v
+        "#]],
+    );
+}
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/resolver.rs b/crates/hir_def/src/resolver.rs
index 85ddc2c47..b2f577649 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -16,13 +16,14 @@ use crate::{
    expr::{ExprId, PatId},
    generics::GenericParams,
    item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
-    nameres::CrateDefMap,
+    nameres::DefMap,
    path::{ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
    AdtId, AssocContainerId, ConstId, ConstParamId, ContainerId, DefWithBodyId, EnumId,
-    EnumVariantId, FunctionId, GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId,
+    EnumVariantId, FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId,
-    ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
+    LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
+    TypeParamId, VariantId,
 };
 #[derive(Debug, Clone, Default)]
@@ -34,7 +35,7 @@ pub struct Resolver {
 // FIXME how to store these best
 #[derive(Debug, Clone)]
 struct ModuleItemMap {
-    crate_def_map: Arc<CrateDefMap>,
+    crate_def_map: Arc<DefMap>,
    module_id: LocalModuleId,
 }
@@ -145,6 +146,19 @@ impl Resolver {
        self.resolve_module_path(db, path, BuiltinShadowMode::Module)
    }
+    pub fn resolve_module_path_in_trait_items(
+        &self,
+        db: &dyn DefDatabase,
+        path: &ModPath,
+    ) -> Option<TraitId> {
+        let (item_map, module) = self.module_scope()?;
+        let (module_res, ..) = item_map.resolve_path(db, module, &path, BuiltinShadowMode::Module);
+        match module_res.take_types()? {
+            ModuleDefId::TraitId(it) => Some(it),
+            _ => None,
+        }
+    }
    pub fn resolve_path_in_type_ns(
        &self,
        db: &dyn DefDatabase,
@@ -415,7 +429,7 @@ impl Resolver {
        let mut traits = FxHashSet::default();
        for scope in &self.scopes {
            if let Scope::ModuleScope(m) = scope {
-                if let Some(prelude) = m.crate_def_map.prelude {
+                if let Some(prelude) = m.crate_def_map.prelude() {
                    let prelude_def_map = db.crate_def_map(prelude.krate);
                    traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                }
@@ -425,7 +439,7 @@ impl Resolver {
        traits
    }
-    fn module_scope(&self) -> Option<(&CrateDefMap, LocalModuleId)> {
+    fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
        self.scopes.iter().rev().find_map(|scope| match scope {
            Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
@@ -445,11 +459,11 @@ impl Resolver {
    pub fn module(&self) -> Option<ModuleId> {
        let (def_map, local_id) = self.module_scope()?;
-        Some(ModuleId { krate: def_map.krate, local_id })
+        Some(ModuleId { krate: def_map.krate(), local_id })
    }
    pub fn krate(&self) -> Option<CrateId> {
-        self.module_scope().map(|t| t.0.krate)
+        self.module_scope().map(|t| t.0.krate())
    }
    pub fn where_predicates_in_scope<'a>(
@@ -484,7 +498,7 @@ pub enum ScopeDef {
    PerNs(PerNs),
    ImplSelfType(ImplId),
    AdtSelfType(AdtId),
-    GenericParam(TypeParamId),
+    GenericParam(GenericParamId),
    Local(PatId),
 }
@@ -508,13 +522,13 @@ impl Scope {
                    seen.insert((name.clone(), scope));
                    f(name.clone(), ScopeDef::PerNs(scope));
                });
-                m.crate_def_map.extern_prelude.iter().for_each(|(name, &def)| {
+                m.crate_def_map.extern_prelude().for_each(|(name, &def)| {
                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
                });
                BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
                    f(name.clone(), ScopeDef::PerNs(def));
                });
-                if let Some(prelude) = m.crate_def_map.prelude {
+                if let Some(prelude) = m.crate_def_map.prelude() {
                    let prelude_def_map = db.crate_def_map(prelude.krate);
                    prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
                        let seen_tuple = (name.clone(), def);
@@ -527,15 +541,21 @@ impl Scope {
            Scope::LocalItemsScope(body) => body.item_scope.entries().for_each(|(name, def)| {
                f(name.clone(), ScopeDef::PerNs(def));
            }),
-            Scope::GenericParams { params, def } => {
+            &Scope::GenericParams { ref params, def: parent } => {
                for (local_id, param) in params.types.iter() {
-                    if let Some(name) = &param.name {
+                    if let Some(ref name) = param.name {
-                        f(
+                        let id = TypeParamId { local_id, parent };
-                            name.clone(),
+                        f(name.clone(), ScopeDef::GenericParam(id.into()))
-                            ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
-                        )
                    }
                }
+                for (local_id, param) in params.consts.iter() {
+                    let id = ConstParamId { local_id, parent };
+                    f(param.name.clone(), ScopeDef::GenericParam(id.into()))
+                }
+                for (local_id, param) in params.lifetimes.iter() {
+                    let id = LifetimeParamId { local_id, parent };
+                    f(param.name.clone(), ScopeDef::GenericParam(id.into()))
+                }
            }
            Scope::ImplDefScope(i) => {
                f(name![Self], ScopeDef::ImplSelfType(*i));
@@ -588,11 +608,7 @@ impl Resolver {
        self.push_scope(Scope::ImplDefScope(impl_def))
    }
-    fn push_module_scope(
+    fn push_module_scope(self, crate_def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
-        self,
-        crate_def_map: Arc<CrateDefMap>,
-        module_id: LocalModuleId,
-    ) -> Resolver {
        self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
    }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 574c0201a..4ff219fb7 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -75,7 +75,7 @@ impl TestDB {
    pub(crate) fn module_for_file(&self, file_id: FileId) -> crate::ModuleId {
        for &krate in self.relevant_crates(file_id).iter() {
            let crate_def_map = self.crate_def_map(krate);
-            for (local_id, data) in crate_def_map.modules.iter() {
+            for (local_id, data) in crate_def_map.modules() {
                if data.origin.file_id() == Some(file_id) {
                    return crate::ModuleId { krate, local_id };
                }
@@ -110,7 +110,7 @@ impl TestDB {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
            let crate_def_map = self.crate_def_map(krate);
-            for (module_id, _) in crate_def_map.modules.iter() {
+            for (module_id, _) in crate_def_map.modules() {
                let file_id = crate_def_map[module_id].origin.file_id();
                files.extend(file_id)
            }
@@ -135,7 +135,7 @@ impl TestDB {
            let crate_def_map = self.crate_def_map(krate);
            let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-            for (module_id, module) in crate_def_map.modules.iter() {
+            for (module_id, module) in crate_def_map.modules() {
                crate_def_map.add_diagnostics(self, module_id, &mut sink);
                for decl in module.scope.declarations() {
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_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index f3bc9d680..3134fa43d 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -5,7 +5,7 @@ use syntax::ast;
 use crate::{
    db::DefDatabase,
-    nameres::CrateDefMap,
+    nameres::DefMap,
    path::{ModPath, PathKind},
    ModuleId,
 };
@@ -116,7 +116,7 @@ impl Visibility {
    pub(crate) fn is_visible_from_def_map(
        self,
-        def_map: &CrateDefMap,
+        def_map: &DefMap,
        from_module: crate::LocalModuleId,
    ) -> bool {
        let to_module = match self {
@@ -135,7 +135,7 @@ impl Visibility {
    ///
    /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
    /// visible in unrelated modules).
-    pub(crate) fn max(self, other: Visibility, def_map: &CrateDefMap) -> Option<Visibility> {
+    pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
        match (self, other) {
            (Visibility::Module(_), Visibility::Public)
            | (Visibility::Public, Visibility::Module(_))
diff --git a/crates/hir_expand/src/ast_id_map.rs b/crates/hir_expand/src/ast_id_map.rs
index 2401b0cc5..0991fffd8 100644
--- a/crates/hir_expand/src/ast_id_map.rs
+++ b/crates/hir_expand/src/ast_id_map.rs
@@ -13,7 +13,7 @@ use std::{
 };
 use la_arena::{Arena, Idx};
-use syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr};
+use syntax::{ast, match_ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr};
 /// `AstId` points to an AST node in a specific file.
 pub struct FileAstId<N: AstNode> {
@@ -72,12 +72,20 @@ impl AstIdMap {
        // get lower ids then children. That is, adding a new child does not
        // change parent's id. This means that, say, adding a new function to a
        // trait does not change ids of top-level items, which helps caching.
-        bdfs(node, |it| match ast::Item::cast(it) {
+        bdfs(node, |it| {
-            Some(module_item) => {
+            match_ast! {
-                res.alloc(module_item.syntax());
+                match it {
-                true
+                    ast::Item(module_item) => {
+                        res.alloc(module_item.syntax());
+                        true
+                    },
+                    ast::BlockExpr(block) => {
+                        res.alloc(block.syntax());
+                        true
+                    },
+                    _ => false,
+                }
            }
-            None => false,
        });
        res
    }
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index eb257579f..b7f1aae8f 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -102,7 +102,7 @@ fn parse_adt(tt: &tt::Subtree) -> Result<BasicAdtInfo, mbe::ExpandError> {
        debug!("name token not found");
        mbe::ExpandError::ConversionError
    })?;
-    let name_token = tt::Ident { id: name_token_id, text: name.text().clone() };
+    let name_token = tt::Ident { id: name_token_id, text: name.text().into() };
    let type_params = params.map_or(0, |type_param_list| type_param_list.type_params().count());
    Ok(BasicAdtInfo { name: name_token, type_params })
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 467516eb7..cb6e23320 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -173,7 +173,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
-    Some(arg.green().clone())
+    Some(arg.green().to_owned())
 }
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
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/name.rs b/crates/hir_expand/src/name.rs
index 95d853b6d..d692cec14 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -38,7 +38,7 @@ impl Name {
    }
    pub fn new_lifetime(lt: &ast::Lifetime) -> Name {
-        Self::new_text(lt.text().clone())
+        Self::new_text(lt.text().into())
    }
    /// Shortcut to create inline plain text name
@@ -47,12 +47,12 @@ impl Name {
    }
    /// Resolve a name from the text of token.
-    fn resolve(raw_text: &SmolStr) -> Name {
+    fn resolve(raw_text: &str) -> Name {
        let raw_start = "r#";
-        if raw_text.as_str().starts_with(raw_start) {
+        if raw_text.starts_with(raw_start) {
            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
        } else {
-            Name::new_text(raw_text.clone())
+            Name::new_text(raw_text.into())
        }
    }
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/Cargo.toml b/crates/hir_ty/Cargo.toml
index 98434b741..db42a00dc 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.47", default-features = false }
+chalk-solve = { version = "0.50", default-features = false }
-chalk-ir = "0.47"
+chalk-ir = "0.50"
-chalk-recursive = "0.47"
+chalk-recursive = "0.50"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index c67a289f2..247da43f2 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -409,7 +409,7 @@ mod tests {
                let crate_def_map = self.crate_def_map(krate);
                let mut fns = Vec::new();
-                for (module_id, _) in crate_def_map.modules.iter() {
+                for (module_id, _) in crate_def_map.modules() {
                    for decl in crate_def_map[module_id].scope.declarations() {
                        let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
                        validate_module_item(self, krate, decl, &mut sink);
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 8a289f52a..f06aeeb42 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -112,7 +112,7 @@ impl TraitImpls {
        let mut impls = Self { map: FxHashMap::default() };
        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules.iter() {
+        for (_module_id, module_data) in crate_def_map.modules() {
            for impl_id in module_data.scope.impls() {
                let target_trait = match db.impl_trait(impl_id) {
                    Some(tr) => tr.value.trait_,
@@ -198,7 +198,7 @@ impl InherentImpls {
        let mut map: FxHashMap<_, Vec<_>> = FxHashMap::default();
        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules.iter() {
+        for (_module_id, module_data) in crate_def_map.modules() {
            for impl_id in module_data.scope.impls() {
                let data = db.impl_data(impl_id);
                if data.target_trait.is_some() {
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
index 646e16bbe..3bbcbc242 100644
--- a/crates/hir_ty/src/test_db.rs
+++ b/crates/hir_ty/src/test_db.rs
@@ -81,7 +81,7 @@ impl TestDB {
    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
        for &krate in self.relevant_crates(file_id).iter() {
            let crate_def_map = self.crate_def_map(krate);
-            for (local_id, data) in crate_def_map.modules.iter() {
+            for (local_id, data) in crate_def_map.modules() {
                if data.origin.file_id() == Some(file_id) {
                    return ModuleId { krate, local_id };
                }
@@ -95,7 +95,7 @@ impl TestDB {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
            let crate_def_map = self.crate_def_map(krate);
-            for (module_id, _) in crate_def_map.modules.iter() {
+            for (module_id, _) in crate_def_map.modules() {
                let file_id = crate_def_map[module_id].origin.file_id();
                files.extend(file_id)
            }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 3b1675f0b..4a3fcea8d 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -18,7 +18,7 @@ use hir_def::{
    db::DefDatabase,
    item_scope::ItemScope,
    keys,
-    nameres::CrateDefMap,
+    nameres::DefMap,
    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
@@ -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", " "))
            };
@@ -221,7 +221,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
 fn visit_module(
    db: &TestDB,
-    crate_def_map: &CrateDefMap,
+    crate_def_map: &DefMap,
    module_id: LocalModuleId,
    cb: &mut dyn FnMut(DefWithBodyId),
 ) {
@@ -249,7 +249,7 @@ fn visit_module(
    fn visit_scope(
        db: &TestDB,
-        crate_def_map: &CrateDefMap,
+        crate_def_map: &DefMap,
        scope: &ItemScope,
        cb: &mut dyn FnMut(DefWithBodyId),
    ) {
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index e8999a7f3..b10a0a78b 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -47,7 +47,7 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
    let mut calls = CallLocations::default();
-    for (&file_id, references) in refs.info.references().iter() {
+    for (&file_id, references) in refs.references().iter() {
        let file = sema.parse(file_id);
        let file = file.syntax();
        for reference in references {
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..9c568c90c 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -153,8 +153,7 @@ impl NavigationTarget {
        node: InFile<&dyn ast::NameOwner>,
        kind: SymbolKind,
    ) -> NavigationTarget {
-        let name =
+        let name = node.value.name().map(|it| it.text().into()).unwrap_or_else(|| "_".into());
-            node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
        let focus_range =
            node.value.name().map(|it| node.with_value(it.syntax()).original_file_range(db).range);
        let frange = node.map(|it| it.syntax()).original_file_range(db);
@@ -295,6 +294,7 @@ impl ToNav for hir::Module {
            ModuleSource::Module(node) => {
                (node.syntax(), node.name().map(|it| it.syntax().text_range()))
            }
+            ModuleSource::BlockExpr(node) => (node.syntax(), None),
        };
        let frange = src.with_value(syntax).original_file_range(db);
        NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, SymbolKind::Module)
@@ -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/display/short_label.rs b/crates/ide/src/display/short_label.rs
index 990f740b8..7ac050473 100644
--- a/crates/ide/src/display/short_label.rs
+++ b/crates/ide/src/display/short_label.rs
@@ -53,6 +53,12 @@ impl ShortLabel for ast::SourceFile {
    }
 }
+impl ShortLabel for ast::BlockExpr {
+    fn short_label(&self) -> Option<String> {
+        None
+    }
+}
 impl ShortLabel for ast::TypeAlias {
    fn short_label(&self) -> Option<String> {
        short_label_from_node(self, "type ")
@@ -90,7 +96,7 @@ impl ShortLabel for ast::Variant {
 impl ShortLabel for ast::ConstParam {
    fn short_label(&self) -> Option<String> {
        let mut buf = "const ".to_owned();
-        buf.push_str(self.name()?.text().as_str());
+        buf.push_str(self.name()?.text());
        if let Some(type_ref) = self.ty() {
            format_to!(buf, ": {}", type_ref.syntax());
        }
@@ -117,6 +123,6 @@ where
 {
    let mut buf = node.visibility().map(|v| format!("{} ", v.syntax())).unwrap_or_default();
    buf.push_str(label);
-    buf.push_str(node.name()?.text().as_str());
+    buf.push_str(node.name()?.text());
    Some(buf)
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index de10406bc..730e0dd0a 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -221,14 +221,31 @@ fn rewrite_intra_doc_link(
    }?;
    let krate = resolved.module(db)?.krate();
    let canonical_path = resolved.canonical_path(db)?;
-    let new_target = get_doc_url(db, &krate)?
+    let mut new_url = get_doc_url(db, &krate)?
        .join(&format!("{}/", krate.display_name(db)?))
        .ok()?
        .join(&canonical_path.replace("::", "/"))
        .ok()?
        .join(&get_symbol_filename(db, &resolved)?)
-        .ok()?
+        .ok()?;
-        .into_string();
+    if let ModuleDef::Trait(t) = resolved {
+        let items = t.items(db);
+        if let Some(field_or_assoc_item) = items.iter().find_map(|assoc_item| {
+            if let Some(name) = assoc_item.name(db) {
+                if link.to_string() == format!("{}::{}", canonical_path, name) {
+                    return Some(FieldOrAssocItem::AssocItem(*assoc_item));
+                }
+            }
+            None
+        }) {
+            if let Some(fragment) = get_symbol_fragment(db, &field_or_assoc_item) {
+                new_url = new_url.join(&fragment).ok()?;
+            }
+        };
+    }
+    let new_target = new_url.into_string();
    let new_title = strip_prefixes_suffixes(title);
    Some((new_target, new_title.to_string()))
 }
@@ -438,10 +455,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/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 17a540972..2d722dee0 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -213,8 +213,8 @@ fn extend_ws(root: &SyntaxNode, ws: SyntaxToken, offset: TextSize) -> TextRange
    let ws_text = ws.text();
    let suffix = TextRange::new(offset, ws.text_range().end()) - ws.text_range().start();
    let prefix = TextRange::new(ws.text_range().start(), offset) - ws.text_range().start();
-    let ws_suffix = &ws_text.as_str()[suffix];
+    let ws_suffix = &ws_text[suffix];
-    let ws_prefix = &ws_text.as_str()[prefix];
+    let ws_prefix = &ws_text[prefix];
    if ws_text.contains('\n') && !ws_suffix.contains('\n') {
        if let Some(node) = ws.next_sibling_or_token() {
            let start = match ws_prefix.rfind('\n') {
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 988a5668f..1a997fa40 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -2,16 +2,14 @@ use either::Either;
 use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
-    symbol_index, RootDatabase,
+    RootDatabase,
 };
 use syntax::{
    ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextSize, TokenAtOffset, T,
 };
 use crate::{
-    display::{ToNav, TryToNav},
+    display::TryToNav, doc_links::extract_definitions_from_markdown, runnables::doc_owner_to_def,
-    doc_links::extract_definitions_from_markdown,
-    runnables::doc_owner_to_def,
    FilePosition, NavigationTarget, RangeInfo,
 };
@@ -38,33 +36,26 @@ pub(crate) fn goto_definition(
        return Some(RangeInfo::new(original_token.text_range(), vec![nav]));
    }
-    let nav_targets = match_ast! {
+    let nav = match_ast! {
        match parent {
            ast::NameRef(name_ref) => {
-                reference_definition(&sema, Either::Right(&name_ref)).to_vec()
+                reference_definition(&sema, Either::Right(&name_ref))
            },
            ast::Name(name) => {
                let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
+                def.try_to_nav(sema.db)
-                vec![nav]
            },
            ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, &lt) {
                let def = name_class.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
+                def.try_to_nav(sema.db)
-                vec![nav]
            } else {
-                reference_definition(&sema, Either::Left(&lt)).to_vec()
+                reference_definition(&sema, Either::Left(&lt))
-            },
-            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,
        }
    };
-    Some(RangeInfo::new(original_token.text_range(), nav_targets))
+    Some(RangeInfo::new(original_token.text_range(), nav.into_iter().collect()))
 }
 fn def_for_doc_comment(
@@ -125,42 +116,16 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
    }
 }
-#[derive(Debug)]
-pub(crate) enum ReferenceResult {
-    Exact(NavigationTarget),
-    Approximate(Vec<NavigationTarget>),
-}
-impl ReferenceResult {
-    fn to_vec(self) -> Vec<NavigationTarget> {
-        match self {
-            ReferenceResult::Exact(target) => vec![target],
-            ReferenceResult::Approximate(vec) => vec,
-        }
-    }
-}
 pub(crate) fn reference_definition(
    sema: &Semantics<RootDatabase>,
    name_ref: Either<&ast::Lifetime, &ast::NameRef>,
-) -> ReferenceResult {
+) -> Option<NavigationTarget> {
    let name_kind = name_ref.either(
        |lifetime| NameRefClass::classify_lifetime(sema, lifetime),
        |name_ref| NameRefClass::classify(sema, name_ref),
-    );
+    )?;
-    if let Some(def) = name_kind {
+    let def = name_kind.referenced(sema.db);
-        let def = def.referenced(sema.db);
+    def.try_to_nav(sema.db)
-        return match def.try_to_nav(sema.db) {
-            Some(nav) => ReferenceResult::Exact(nav),
-            None => ReferenceResult::Approximate(Vec::new()),
-        };
-    }
-    // Fallback index based approach:
-    let name = name_ref.either(ast::Lifetime::text, ast::NameRef::text);
-    let navs =
-        symbol_index::index_resolve(sema.db, name).into_iter().map(|s| s.to_nav(sema.db)).collect();
-    ReferenceResult::Approximate(navs)
 }
 #[cfg(test)]
@@ -197,12 +162,12 @@ mod tests {
    fn goto_def_for_extern_crate() {
        check(
            r#"
-            //- /main.rs crate:main deps:std
+//- /main.rs crate:main deps:std
-            extern crate std$0;
+extern crate std$0;
-            //- /std/lib.rs crate:std
+//- /std/lib.rs crate:std
-            // empty
+// empty
-            //^ file
+//^ file
-            "#,
+"#,
        )
    }
@@ -210,12 +175,12 @@ mod tests {
    fn goto_def_for_renamed_extern_crate() {
        check(
            r#"
-            //- /main.rs crate:main deps:std
+//- /main.rs crate:main deps:std
-            extern crate std as abc$0;
+extern crate std as abc$0;
-            //- /std/lib.rs crate:std
+//- /std/lib.rs crate:std
-            // empty
+// empty
-            //^ file
+//^ file
-            "#,
+"#,
        )
    }
@@ -302,13 +267,13 @@ fn bar() {
    fn goto_def_for_macros_from_other_crates() {
        check(
            r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 use foo::foo;
 fn bar() {
    $0foo!();
 }
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 #[macro_export]
 macro_rules! foo { () => { () } }
           //^^^
@@ -320,10 +285,10 @@ macro_rules! foo { () => { () } }
    fn goto_def_for_macros_in_use_tree() {
        check(
            r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 use foo::foo$0;
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 #[macro_export]
 macro_rules! foo { () => { () } }
           //^^^
@@ -981,10 +946,10 @@ type Alias<T> = T$0;
    fn goto_def_for_macro_container() {
        check(
            r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 foo::module$0::mac!();
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 pub mod module {
      //^^^^^^
    #[macro_export]
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 6022bd275..d47a4cb0f 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,
        }
    };
@@ -183,12 +182,7 @@ fn runnable_action(
 ) -> Option<HoverAction> {
    match def {
        Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => match it.definition_source(sema.db).value {
+            ModuleDef::Module(it) => runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it)),
-                ModuleSource::Module(it) => {
-                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
-                }
-                _ => None,
-            },
            ModuleDef::Function(func) => {
                let src = func.source(sema.db)?;
                if src.file_id != file_id.into() {
@@ -327,6 +321,7 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
                match it.definition_source(db).value {
                    ModuleSource::Module(it) => it.short_label(),
                    ModuleSource::SourceFile(it) => it.short_label(),
+                    ModuleSource::BlockExpr(it) => it.short_label(),
                },
                mod_path,
            ),
@@ -1831,6 +1826,35 @@ pub struct B$0ar
            "#]],
        );
    }
+    #[test]
+    fn test_hover_intra_link_reference_to_trait_method() {
+        check(
+            r#"
+pub trait Foo {
+    fn buzz() -> usize;
+}
+/// [Foo][buzz]
+///
+/// [buzz]: Foo::buzz
+pub struct B$0ar
+"#,
+            expect![[r#"
+                *Bar*
+                ```rust
+                test
+                ```
+                ```rust
+                pub struct Bar
+                ```
+                ---
+                [Foo](https://docs.rs/test/*/test/trait.Foo.html#tymethod.buzz)
+            "#]],
+        );
+    }
    #[test]
    fn test_hover_external_url() {
@@ -3223,7 +3247,7 @@ impl Foo {
 }
 "#,
            expect![[r#"
-                *&self*
+                *self*
                ```rust
                &Foo
@@ -3243,7 +3267,7 @@ impl Foo {
 }
 "#,
            expect![[r#"
-                *self: Arc<Foo>*
+                *self*
                ```rust
                Arc<Foo>
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index a2039fcc7..54485fd30 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -411,7 +411,7 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
    match expr {
        ast::Expr::MethodCallExpr(method_call_expr) => {
            let name_ref = method_call_expr.name_ref()?;
-            match name_ref.text().as_str() {
+            match name_ref.text() {
                "clone" => method_call_expr.receiver().map(|rec| rec.to_string()),
                name_ref => Some(name_ref.to_owned()),
            }
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 981467c8d..631bde0f1 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -59,7 +59,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextS
        // The node is either the first or the last in the file
        let suff = &token.text()[TextRange::new(
            offset - token.text_range().start() + TextSize::of('\n'),
-            TextSize::of(token.text().as_str()),
+            TextSize::of(token.text()),
        )];
        let spaces = suff.bytes().take_while(|&b| b == b' ').count();
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index f8d69382e..567b8117e 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,
@@ -372,9 +369,7 @@ impl Analysis {
        position: FilePosition,
        search_scope: Option<SearchScope>,
    ) -> Cancelable<Option<ReferenceSearchResult>> {
-        self.with_db(|db| {
+        self.with_db(|db| references::find_all_refs(&Semantics::new(db), position, search_scope))
-            references::find_all_refs(&Semantics::new(db), position, search_scope).map(|it| it.info)
-        })
    }
    /// Finds all methods and free functions for the file. Does not return tests!
@@ -481,6 +476,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 +486,7 @@ impl Analysis {
                    position,
                    full_import_path,
                    imported_name,
+                    import_for_trait_assoc_item,
                )
            })?
            .unwrap_or_default())
@@ -523,7 +520,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..3a4f4d80b 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -25,7 +25,7 @@ use syntax::{
    AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
 };
-use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
+use crate::{display::TryToNav, FilePosition, NavigationTarget};
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
@@ -41,14 +41,6 @@ pub struct Declaration {
 }
 impl ReferenceSearchResult {
-    pub fn declaration(&self) -> &Declaration {
-        &self.declaration
-    }
-    pub fn decl_target(&self) -> &NavigationTarget {
-        &self.declaration.nav
-    }
    pub fn references(&self) -> &UsageSearchResult {
        &self.references
    }
@@ -87,7 +79,7 @@ pub(crate) fn find_all_refs(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    search_scope: Option<SearchScope>,
-) -> Option<RangeInfo<ReferenceSearchResult>> {
+) -> Option<ReferenceSearchResult> {
    let _p = profile::span("find_all_refs");
    let syntax = sema.parse(position.file_id).syntax().clone();
@@ -105,7 +97,7 @@ pub(crate) fn find_all_refs(
        )
    };
-    let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
+    let def = find_name(&sema, &syntax, position, opt_name)?;
    let mut usages = def.usages(sema).set_scope(search_scope).all();
    usages
@@ -139,7 +131,7 @@ pub(crate) fn find_all_refs(
    let declaration = Declaration { nav, kind, access: decl_access(&def, &syntax, decl_range) };
-    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references: usages }))
+    Some(ReferenceSearchResult { declaration, references: usages })
 }
 fn find_name(
@@ -147,35 +139,27 @@ fn find_name(
    syntax: &SyntaxNode,
    position: FilePosition,
    opt_name: Option<ast::Name>,
-) -> Option<RangeInfo<Definition>> {
+) -> Option<Definition> {
-    if let Some(name) = opt_name {
+    let def = if let Some(name) = opt_name {
-        let def = NameClass::classify(sema, &name)?.referenced_or_defined(sema.db);
+        NameClass::classify(sema, &name)?.referenced_or_defined(sema.db)
-        let FileRange { range, .. } = sema.original_range(name.syntax());
+    } else if let Some(lifetime) =
-        return Some(RangeInfo::new(range, def));
-    }
-    let (FileRange { range, .. }, def) = if let Some(lifetime) =
        sema.find_node_at_offset_with_descend::<ast::Lifetime>(&syntax, position.offset)
    {
-        if let Some(def) = NameRefClass::classify_lifetime(sema, &lifetime)
+        if let Some(def) =
-            .map(|class| NameRefClass::referenced(class, sema.db))
+            NameRefClass::classify_lifetime(sema, &lifetime).map(|class| class.referenced(sema.db))
        {
-            (sema.original_range(lifetime.syntax()), def)
+            def
        } else {
-            (
+            NameClass::classify_lifetime(sema, &lifetime)?.referenced_or_defined(sema.db)
-                sema.original_range(lifetime.syntax()),
-                NameClass::classify_lifetime(sema, &lifetime)?.referenced_or_defined(sema.db),
-            )
        }
+    } else if let Some(name_ref) =
+        sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)
+    {
+        NameRefClass::classify(sema, &name_ref)?.referenced(sema.db)
    } else {
-        let name_ref =
+        return None;
-            sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
-        (
-            sema.original_range(name_ref.syntax()),
-            NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
-        )
    };
-    Some(RangeInfo::new(range, def))
+    Some(def)
 }
 fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option<ReferenceAccess> {
@@ -930,6 +914,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/runnables.rs b/crates/ide/src/runnables.rs
index f5ee7de86..975abf47f 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -6,9 +6,10 @@ use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
 use ide_db::{defs::Definition, RootDatabase};
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
+    ast::{self, AstNode, AttrsOwner},
    match_ast, SyntaxNode,
 };
+use test_utils::mark;
 use crate::{
    display::{ToNav, TryToNav},
@@ -95,27 +96,45 @@ impl Runnable {
 // |===
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
    let sema = Semantics::new(db);
-    let source_file = sema.parse(file_id);
+    let module = match sema.to_module_def(file_id) {
-    source_file
+        None => return Vec::new(),
-        .syntax()
+        Some(it) => it,
-        .descendants()
+    };
-        .filter_map(|item| {
-            let runnable = match_ast! {
+    let mut res = Vec::new();
-                match item {
+    runnables_mod(&sema, &mut res, module);
-                    ast::Fn(func) => {
+    res
-                        let def = sema.to_def(&func)?;
+}
-                        runnable_fn(&sema, def)
-                    },
+fn runnables_mod(sema: &Semantics<RootDatabase>, acc: &mut Vec<Runnable>, module: hir::Module) {
-                    ast::Module(it) => runnable_mod(&sema, it),
+    acc.extend(module.declarations(sema.db).into_iter().filter_map(|def| {
-                    _ => None,
+        let runnable = match def {
-                }
+            hir::ModuleDef::Module(it) => runnable_mod(&sema, it),
-            };
+            hir::ModuleDef::Function(it) => runnable_fn(&sema, it),
-            runnable.or_else(|| match doc_owner_to_def(&sema, item)? {
+            _ => None,
-                Definition::ModuleDef(def) => module_def_doctest(&sema, def),
+        };
-                _ => None,
+        runnable.or_else(|| module_def_doctest(&sema, def))
-            })
+    }));
-        })
-        .collect()
+    acc.extend(module.impl_defs(sema.db).into_iter().flat_map(|it| it.items(sema.db)).filter_map(
+        |def| match def {
+            hir::AssocItem::Function(it) => {
+                runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
+            }
+            hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
+            hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
+        },
+    ));
+    for def in module.declarations(sema.db) {
+        if let hir::ModuleDef::Module(submodule) = def {
+            match submodule.definition_source(sema.db).value {
+                hir::ModuleSource::Module(_) => runnables_mod(sema, acc, submodule),
+                hir::ModuleSource::SourceFile(_) => mark::hit!(dont_recurse_in_outline_submodules),
+                hir::ModuleSource::BlockExpr(_) => {} // inner items aren't runnable
+            }
+        }
+    }
 }
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -150,26 +169,16 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
    Some(Runnable { nav, kind, cfg })
 }
-pub(crate) fn runnable_mod(
+pub(crate) fn runnable_mod(sema: &Semantics<RootDatabase>, def: hir::Module) -> Option<Runnable> {
-    sema: &Semantics<RootDatabase>,
+    if !has_test_function_or_multiple_test_submodules(sema, &def) {
-    module: ast::Module,
-) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
        return None;
    }
-    let module_def = sema.to_def(&module)?;
+    let path =
+        def.path_to_root(sema.db).into_iter().rev().filter_map(|it| it.name(sema.db)).join("::");
-    let path = module_def
-        .path_to_root(sema.db)
-        .into_iter()
-        .rev()
-        .filter_map(|it| it.name(sema.db))
-        .join("::");
-    let def = sema.to_def(&module)?;
    let attrs = def.attrs(sema.db);
    let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
+    let nav = def.to_nav(sema.db);
    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
 }
@@ -289,35 +298,37 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
 // We could create runnables for modules with number_of_test_submodules > 0,
 // but that bloats the runnables for no real benefit, since all tests can be run by the submodule already
-fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
+fn has_test_function_or_multiple_test_submodules(
-    if let Some(item_list) = module.item_list() {
+    sema: &Semantics<RootDatabase>,
-        let mut number_of_test_submodules = 0;
+    module: &hir::Module,
+) -> bool {
-        for item in item_list.items() {
+    let mut number_of_test_submodules = 0;
-            match item {
-                ast::Item::Fn(f) => {
+    for item in module.declarations(sema.db) {
-                    if test_related_attribute(&f).is_some() {
+        match item {
+            hir::ModuleDef::Function(f) => {
+                if let Some(it) = f.source(sema.db) {
+                    if test_related_attribute(&it.value).is_some() {
                        return true;
                    }
                }
-                ast::Item::Module(submodule) => {
+            }
-                    if has_test_function_or_multiple_test_submodules(&submodule) {
+            hir::ModuleDef::Module(submodule) => {
-                        number_of_test_submodules += 1;
+                if has_test_function_or_multiple_test_submodules(sema, &submodule) {
-                    }
+                    number_of_test_submodules += 1;
                }
-                _ => (),
            }
+            _ => (),
        }
-        number_of_test_submodules > 1
-    } else {
-        false
    }
+    number_of_test_submodules > 1
 }
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
+    use test_utils::mark;
    use crate::fixture;
@@ -753,6 +764,21 @@ mod root_tests {
                            file_id: FileId(
                                0,
                            ),
+                            full_range: 202..286,
+                            focus_range: 206..220,
+                            name: "nested_tests_2",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "root_tests::nested_tests_0::nested_tests_2",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
                            full_range: 84..126,
                            focus_range: 107..121,
                            name: "nested_test_11",
@@ -793,21 +819,6 @@ mod root_tests {
                            file_id: FileId(
                                0,
                            ),
-                            full_range: 202..286,
-                            focus_range: 206..220,
-                            name: "nested_tests_2",
-                            kind: Module,
-                        },
-                        kind: TestMod {
-                            path: "root_tests::nested_tests_0::nested_tests_2",
-                        },
-                        cfg: None,
-                    },
-                    Runnable {
-                        nav: NavigationTarget {
-                            file_id: FileId(
-                                0,
-                            ),
                            full_range: 235..276,
                            focus_range: 258..271,
                            name: "nested_test_2",
@@ -982,4 +993,85 @@ impl Foo {
            "#]],
        );
    }
+    #[test]
+    fn test_runnables_in_macro() {
+        check(
+            r#"
+//- /lib.rs
+$0
+macro_rules! gen {
+    () => {
+        #[test]
+        fn foo_test() {
+        }
+    }
+}
+mod tests {
+    gen!();
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 90..115,
+                            focus_range: 94..99,
+                            name: "tests",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "tests",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 106..113,
+                            focus_range: 106..113,
+                            name: "foo_test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "tests::foo_test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
+    #[test]
+    fn dont_recurse_in_outline_submodules() {
+        mark::check!(dont_recurse_in_outline_submodules);
+        check(
+            r#"
+//- /lib.rs
+$0
+mod m;
+//- /m.rs
+mod tests {
+    #[test]
+    fn t() {}
+}
+"#,
+            &[],
+            expect![[r#"
+                []
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/status.rs b/crates/ide/src/status.rs
index e10d7c3a4..137c38c0d 100644
--- a/crates/ide/src/status.rs
+++ b/crates/ide/src/status.rs
@@ -38,6 +38,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
    format_to!(buf, "{}\n", syntax_tree_stats(db));
    format_to!(buf, "{} (macros)\n", macro_syntax_tree_stats(db));
    format_to!(buf, "{} total\n", memory_usage());
+    format_to!(buf, "\ncounts:\n{}", profile::countme::get_all());
    if let Some(file_id) = file_id {
        format_to!(buf, "\nfile info:\n");
@@ -60,6 +61,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
            None => format_to!(buf, "does not belong to any crate"),
        }
    }
    buf
 }
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index a74ca844b..8a9b5ca8c 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -30,7 +30,7 @@ fn is_format_string(string: &ast::String) -> Option<()> {
    let parent = string.syntax().parent();
    let name = parent.parent().and_then(ast::MacroCall::cast)?.path()?.segment()?.name_ref()?;
-    if !matches!(name.text().as_str(), "format_args" | "format_args_nl") {
+    if !matches!(name.text(), "format_args" | "format_args_nl") {
        return None;
    }
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_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 281461493..8cdc3688f 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -116,7 +116,7 @@ pub(super) fn doc_comment(hl: &mut Highlights, node: &SyntaxNode) {
            None => (),
        }
-        let line: &str = comment.text().as_str();
+        let line: &str = comment.text();
        let range = comment.syntax().text_range();
        let mut pos = TextSize::of(comment.prefix());
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/apply_change.rs b/crates/ide_db/src/apply_change.rs
index c770a236b..9d9b6de7a 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -149,6 +149,7 @@ impl RootDatabase {
            // DefDatabase
            hir::db::ItemTreeQuery
+            hir::db::BlockDefMapQuery
            hir::db::CrateDefMapQueryQuery
            hir::db::StructDataQuery
            hir::db::UnionDataQuery
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 231e886a9..a8091dbee 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)))
@@ -346,7 +343,7 @@ impl NameRefClass {
                        hir::AssocItem::TypeAlias(it) => Some(*it),
                        _ => None,
                    })
-                    .find(|alias| alias.name(sema.db).to_string() == **name_ref.text())
+                    .find(|alias| &alias.name(sema.db).to_string() == name_ref.text())
                {
                    return Some(NameRefClass::Definition(Definition::ModuleDef(
                        ModuleDef::TypeAlias(ty),
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.rs b/crates/ide_db/src/helpers/insert_use.rs
index 877d4f1c7..fd4035198 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -507,7 +507,7 @@ impl ImportGroup {
            PathSegmentKind::SelfKw => ImportGroup::ThisModule,
            PathSegmentKind::SuperKw => ImportGroup::SuperModule,
            PathSegmentKind::CrateKw => ImportGroup::ThisCrate,
-            PathSegmentKind::Name(name) => match name.text().as_str() {
+            PathSegmentKind::Name(name) => match name.text() {
                "std" => ImportGroup::Std,
                "core" => ImportGroup::Std,
                _ => ImportGroup::ExternCrate,
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/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index 0ecb13a64..b9ba0aed5 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -228,6 +228,15 @@ impl Definition {
                            // so do nothing.
                        }
                    }
+                    ModuleSource::BlockExpr(b) => {
+                        if is_first {
+                            let range = Some(b.syntax().text_range());
+                            res.insert(file_id, range);
+                        } else {
+                            // We have already added the enclosing file to the search scope,
+                            // so do nothing.
+                        }
+                    }
                    ModuleSource::SourceFile(_) => {
                        res.insert(file_id, None);
                    }
@@ -257,6 +266,7 @@ impl Definition {
        let mut res = FxHashMap::default();
        let range = match module_src.value {
            ModuleSource::Module(m) => Some(m.syntax().text_range()),
+            ModuleSource::BlockExpr(b) => Some(b.syntax().text_range()),
            ModuleSource::SourceFile(_) => None,
        };
        res.insert(file_id, range);
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index 0aa6a0765..e954bd72e 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -191,7 +191,7 @@ pub fn crate_symbols(db: &RootDatabase, krate: CrateId, query: Query) -> Vec<Fil
    let def_map = db.crate_def_map(krate);
    let mut files = Vec::new();
-    let mut modules = vec![def_map.root];
+    let mut modules = vec![def_map.root()];
    while let Some(module) = modules.pop() {
        let data = &def_map[module];
        files.extend(data.origin.file_id());
@@ -209,7 +209,7 @@ pub fn crate_symbols(db: &RootDatabase, krate: CrateId, query: Query) -> Vec<Fil
    query.search(&buf)
 }
-pub fn index_resolve(db: &RootDatabase, name: &SmolStr) -> Vec<FileSymbol> {
+pub fn index_resolve(db: &RootDatabase, name: &str) -> Vec<FileSymbol> {
    let mut query = Query::new(name.to_string());
    query.exact();
    query.limit(4);
@@ -409,7 +409,7 @@ fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
    fn decl<N: NameOwner>(node: N) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
        let name = node.name()?;
        let name_range = name.syntax().text_range();
-        let name = name.text().clone();
+        let name = name.text().into();
        let ptr = SyntaxNodePtr::new(node.syntax());
        Some((name, ptr, name_range))
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index e648519f9..0cdc175be 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -16,16 +16,18 @@ use crate::ExpandError;
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum TokenTextRange {
    Token(TextRange),
-    Delimiter(TextRange, TextRange),
+    Delimiter(TextRange),
 }
 impl TokenTextRange {
    pub fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
        match self {
            TokenTextRange::Token(it) => Some(it),
-            TokenTextRange::Delimiter(open, close) => match kind {
+            TokenTextRange::Delimiter(it) => match kind {
-                T!['{'] | T!['('] | T!['['] => Some(open),
+                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
-                T!['}'] | T![')'] | T![']'] => Some(close),
+                T!['}'] | T![')'] | T![']'] => {
+                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
+                }
                _ => None,
            },
        }
@@ -51,6 +53,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))
 }
@@ -113,8 +116,10 @@ impl TokenMap {
    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
            TokenTextRange::Token(it) => *it == relative_range,
-            TokenTextRange::Delimiter(open, close) => {
+            TokenTextRange::Delimiter(it) => {
-                *open == relative_range || *close == relative_range
+                let open = TextRange::at(it.start(), 1.into());
+                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
+                open == relative_range || close == relative_range
            }
        })?;
        Some(token_id)
@@ -136,15 +141,17 @@ impl TokenMap {
        close_relative_range: TextRange,
    ) -> usize {
        let res = self.entries.len();
-        self.entries
+        let cover = open_relative_range.cover(close_relative_range);
-            .push((token_id, TokenTextRange::Delimiter(open_relative_range, close_relative_range)));
+        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
        res
    }
    fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
        let (_, token_text_range) = &mut self.entries[idx];
-        if let TokenTextRange::Delimiter(dim, _) = token_text_range {
+        if let TokenTextRange::Delimiter(dim) = token_text_range {
-            *token_text_range = TokenTextRange::Delimiter(*dim, close_relative_range);
+            let cover = dim.cover(close_relative_range);
+            *token_text_range = TokenTextRange::Delimiter(cover);
        }
    }
@@ -500,7 +507,7 @@ impl SrcToken for SynToken {
        }
    }
    fn to_text(&self) -> SmolStr {
-        self.token().text().clone()
+        self.token().text().into()
    }
 }
@@ -593,7 +600,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)
    }
 }
@@ -674,10 +682,8 @@ impl<'a> TreeSink for TtTreeSink<'a> {
            self.text_pos += TextSize::of(text);
        }
-        let text = SmolStr::new(self.buf.as_str());
+        self.inner.token(kind, self.buf.as_str());
        self.buf.clear();
-        self.inner.token(kind, text);
        // Add whitespace between adjoint puncts
        let next = last.bump();
        if let (
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/event.rs b/crates/parser/src/event.rs
index a7d06a815..903668892 100644
--- a/crates/parser/src/event.rs
+++ b/crates/parser/src/event.rs
@@ -38,14 +38,16 @@ pub(crate) enum Event {
    ///
    /// The events for it would look like this:
    ///
-    ///
+    /// ```text
    /// START(PATH) IDENT('foo') FINISH START(PATH) T![::] IDENT('bar') FINISH
    ///       |                          /\
    ///       |                          |
    ///       +------forward-parent------+
+    /// ```
    ///
    /// And the tree would look like this
    ///
+    /// ```text
    ///    +--PATH---------+
    ///    |   |           |
    ///    |   |           |
@@ -54,6 +56,7 @@ pub(crate) enum Event {
    ///   PATH
    ///    |
    ///   'foo'
+    /// ```
    ///
    /// See also `CompletedMarker::precede`.
    Start {
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/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..cc7da27f7 100644
--- a/crates/profile/Cargo.toml
+++ b/crates/profile/Cargo.toml
@@ -14,12 +14,15 @@ once_cell = "1.3.1"
 cfg-if = "1"
 libc = "0.2.73"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
+countme = { version = "2.0.0-pre.2", features = ["enable"] }
+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/hprof.rs b/crates/profile/src/hprof.rs
index 8957ea016..29d2ed518 100644
--- a/crates/profile/src/hprof.rs
+++ b/crates/profile/src/hprof.rs
@@ -3,6 +3,7 @@ use once_cell::sync::Lazy;
 use std::{
    cell::RefCell,
    collections::{BTreeMap, HashSet},
+    env,
    io::{stderr, Write},
    sync::{
        atomic::{AtomicBool, Ordering},
@@ -18,7 +19,8 @@ use crate::tree::{Idx, Tree};
 /// env RA_PROFILE=foo|bar|baz   // enabled only selected entries
 /// env RA_PROFILE=*@3>10        // dump everything, up to depth 3, if it takes more than 10 ms
 pub fn init() {
-    let spec = std::env::var("RA_PROFILE").unwrap_or_default();
+    countme::enable(env::var("RA_COUNT").is_ok());
+    let spec = env::var("RA_PROFILE").unwrap_or_default();
    init_from(&spec);
 }
diff --git a/crates/profile/src/lib.rs b/crates/profile/src/lib.rs
index aa6ccc36c..79dba47d5 100644
--- a/crates/profile/src/lib.rs
+++ b/crates/profile/src/lib.rs
@@ -15,6 +15,13 @@ pub use crate::{
    stop_watch::{StopWatch, StopWatchSpan},
 };
+pub use countme;
+/// Include `_c: Count<Self>` field in important structs to count them.
+///
+/// To view the counts, run with `RA_COUNT=1`. The overhead of disabled count is
+/// almost zero.
+pub use countme::Count;
 thread_local!(static IN_SCOPE: RefCell<bool> = RefCell::new(false));
 /// Allows to check if the current code is withing some dynamic scope, can be
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/build_data.rs b/crates/project_model/src/build_data.rs
new file mode 100644
index 000000000..cf32995e0
--- /dev/null
+++ b/crates/project_model/src/build_data.rs
@@ -0,0 +1,206 @@
+//! Handles build script specific information
+use std::{
+    ffi::OsStr,
+    io::BufReader,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
+use anyhow::Result;
+use cargo_metadata::{BuildScript, Message, Package, PackageId};
+use itertools::Itertools;
+use paths::{AbsPath, AbsPathBuf};
+use rustc_hash::FxHashMap;
+use stdx::JodChild;
+use crate::{cfg_flag::CfgFlag, CargoConfig};
+#[derive(Debug, Clone, Default)]
+pub(crate) struct BuildDataMap {
+    data: FxHashMap<PackageId, BuildData>,
+}
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct BuildData {
+    /// List of config flags defined by this package's build script
+    pub cfgs: Vec<CfgFlag>,
+    /// List of cargo-related environment variables with their value
+    ///
+    /// If the package has a build script which defines environment variables,
+    /// they can also be found here.
+    pub envs: Vec<(String, String)>,
+    /// Directory where a build script might place its output
+    pub out_dir: Option<AbsPathBuf>,
+    /// Path to the proc-macro library file if this package exposes proc-macros
+    pub proc_macro_dylib_path: Option<AbsPathBuf>,
+}
+impl BuildDataMap {
+    pub(crate) fn new(
+        cargo_toml: &AbsPath,
+        cargo_features: &CargoConfig,
+        packages: &Vec<Package>,
+        progress: &dyn Fn(String),
+    ) -> Result<BuildDataMap> {
+        let mut cmd = Command::new(toolchain::cargo());
+        cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
+            .arg(cargo_toml.as_ref());
+        // --all-targets includes tests, benches and examples in addition to the
+        // default lib and bins. This is an independent concept from the --targets
+        // flag below.
+        cmd.arg("--all-targets");
+        if let Some(target) = &cargo_features.target {
+            cmd.args(&["--target", target]);
+        }
+        if cargo_features.all_features {
+            cmd.arg("--all-features");
+        } else {
+            if cargo_features.no_default_features {
+                // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
+                // https://github.com/oli-obk/cargo_metadata/issues/79
+                cmd.arg("--no-default-features");
+            }
+            if !cargo_features.features.is_empty() {
+                cmd.arg("--features");
+                cmd.arg(cargo_features.features.join(" "));
+            }
+        }
+        cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
+        let mut child = cmd.spawn().map(JodChild)?;
+        let child_stdout = child.stdout.take().unwrap();
+        let stdout = BufReader::new(child_stdout);
+        let mut res = BuildDataMap::default();
+        for message in cargo_metadata::Message::parse_stream(stdout) {
+            if let Ok(message) = message {
+                match message {
+                    Message::BuildScriptExecuted(BuildScript {
+                        package_id,
+                        out_dir,
+                        cfgs,
+                        env,
+                        ..
+                    }) => {
+                        let cfgs = {
+                            let mut acc = Vec::new();
+                            for cfg in cfgs {
+                                match cfg.parse::<CfgFlag>() {
+                                    Ok(it) => acc.push(it),
+                                    Err(err) => {
+                                        anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
+                                    }
+                                };
+                            }
+                            acc
+                        };
+                        let res = res.data.entry(package_id.clone()).or_default();
+                        // cargo_metadata crate returns default (empty) path for
+                        // older cargos, which is not absolute, so work around that.
+                        if out_dir != PathBuf::default() {
+                            let out_dir = AbsPathBuf::assert(out_dir);
+                            res.out_dir = Some(out_dir);
+                            res.cfgs = cfgs;
+                        }
+                        res.envs = env;
+                    }
+                    Message::CompilerArtifact(message) => {
+                        progress(format!("metadata {}", message.target.name));
+                        if message.target.kind.contains(&"proc-macro".to_string()) {
+                            let package_id = message.package_id;
+                            // Skip rmeta file
+                            if let Some(filename) =
+                                message.filenames.iter().find(|name| is_dylib(name))
+                            {
+                                let filename = AbsPathBuf::assert(filename.clone());
+                                let res = res.data.entry(package_id.clone()).or_default();
+                                res.proc_macro_dylib_path = Some(filename);
+                            }
+                        }
+                    }
+                    Message::CompilerMessage(message) => {
+                        progress(message.target.name.clone());
+                    }
+                    Message::Unknown => (),
+                    Message::BuildFinished(_) => {}
+                    Message::TextLine(_) => {}
+                }
+            }
+        }
+        res.inject_cargo_env(packages);
+        Ok(res)
+    }
+    pub(crate) fn with_cargo_env(packages: &Vec<Package>) -> Self {
+        let mut res = Self::default();
+        res.inject_cargo_env(packages);
+        res
+    }
+    pub(crate) fn get(&self, id: &PackageId) -> Option<&BuildData> {
+        self.data.get(id)
+    }
+    fn inject_cargo_env(&mut self, packages: &Vec<Package>) {
+        for meta_pkg in packages {
+            let resource = self.data.entry(meta_pkg.id.clone()).or_default();
+            inject_cargo_env(meta_pkg, &mut resource.envs);
+            if let Some(out_dir) = &resource.out_dir {
+                // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
+                if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
+                    resource.envs.push(("OUT_DIR".to_string(), out_dir));
+                }
+            }
+        }
+    }
+}
+// FIXME: File a better way to know if it is a dylib
+fn is_dylib(path: &Path) -> bool {
+    match path.extension().and_then(OsStr::to_str).map(|it| it.to_string().to_lowercase()) {
+        None => false,
+        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
+    }
+}
+/// Recreates the compile-time environment variables that Cargo sets.
+///
+/// Should be synced with <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
+fn inject_cargo_env(package: &cargo_metadata::Package, env: &mut Vec<(String, String)>) {
+    // FIXME: Missing variables:
+    // CARGO, CARGO_PKG_HOMEPAGE, CARGO_CRATE_NAME, CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
+    let mut manifest_dir = package.manifest_path.clone();
+    manifest_dir.pop();
+    if let Some(cargo_manifest_dir) = manifest_dir.to_str() {
+        env.push(("CARGO_MANIFEST_DIR".into(), cargo_manifest_dir.into()));
+    }
+    env.push(("CARGO_PKG_VERSION".into(), package.version.to_string()));
+    env.push(("CARGO_PKG_VERSION_MAJOR".into(), package.version.major.to_string()));
+    env.push(("CARGO_PKG_VERSION_MINOR".into(), package.version.minor.to_string()));
+    env.push(("CARGO_PKG_VERSION_PATCH".into(), package.version.patch.to_string()));
+    let pre = package.version.pre.iter().map(|id| id.to_string()).format(".");
+    env.push(("CARGO_PKG_VERSION_PRE".into(), pre.to_string()));
+    let authors = package.authors.join(";");
+    env.push(("CARGO_PKG_AUTHORS".into(), authors));
+    env.push(("CARGO_PKG_NAME".into(), package.name.clone()));
+    env.push(("CARGO_PKG_DESCRIPTION".into(), package.description.clone().unwrap_or_default()));
+    //env.push(("CARGO_PKG_HOMEPAGE".into(), package.homepage.clone().unwrap_or_default()));
+    env.push(("CARGO_PKG_REPOSITORY".into(), package.repository.clone().unwrap_or_default()));
+    env.push(("CARGO_PKG_LICENSE".into(), package.license.clone().unwrap_or_default()));
+    let license_file =
+        package.license_file.as_ref().map(|buf| buf.display().to_string()).unwrap_or_default();
+    env.push(("CARGO_PKG_LICENSE_FILE".into(), license_file));
+}
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index c0ed37fc1..c8a5333c4 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -1,24 +1,15 @@
 //! FIXME: write short doc here
-use std::{
+use std::{convert::TryInto, ops, process::Command};
-    convert::TryInto,
-    ffi::OsStr,
-    io::BufReader,
-    ops,
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-};
 use anyhow::{Context, Result};
 use base_db::Edition;
-use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
+use cargo_metadata::{CargoOpt, MetadataCommand};
-use itertools::Itertools;
 use la_arena::{Arena, Idx};
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use stdx::JodChild;
-use crate::cfg_flag::CfgFlag;
+use crate::build_data::{BuildData, BuildDataMap};
 use crate::utf8_stdout;
 /// `CargoWorkspace` represents the logical structure of, well, a Cargo
@@ -99,19 +90,12 @@ pub struct PackageData {
    pub dependencies: Vec<PackageDependency>,
    /// Rust edition for this package
    pub edition: Edition,
-    /// List of features to activate
+    /// Features provided by the crate, mapped to the features required by that feature.
-    pub features: Vec<String>,
+    pub features: FxHashMap<String, Vec<String>>,
-    /// List of config flags defined by this package's build script
+    /// List of features enabled on this package
-    pub cfgs: Vec<CfgFlag>,
+    pub active_features: Vec<String>,
-    /// List of cargo-related environment variables with their value
+    /// Build script related data for this package
-    ///
+    pub build_data: BuildData,
-    /// If the package has a build script which defines environment variables,
-    /// they can also be found here.
-    pub envs: Vec<(String, String)>,
-    /// Directory where a build script might place its output
-    pub out_dir: Option<AbsPathBuf>,
-    /// Path to the proc-macro library file if this package exposes proc-macros
-    pub proc_macro_dylib_path: Option<AbsPathBuf>,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -244,17 +228,11 @@ impl CargoWorkspace {
            )
        })?;
-        let mut out_dir_by_id = FxHashMap::default();
+        let resources = if config.load_out_dirs_from_check {
-        let mut cfgs = FxHashMap::default();
+            BuildDataMap::new(cargo_toml, config, &meta.packages, progress)?
-        let mut envs = FxHashMap::default();
+        } else {
-        let mut proc_macro_dylib_paths = FxHashMap::default();
+            BuildDataMap::with_cargo_env(&meta.packages)
-        if config.load_out_dirs_from_check {
+        };
-            let resources = load_extern_resources(cargo_toml, config, progress)?;
-            out_dir_by_id = resources.out_dirs;
-            cfgs = resources.cfgs;
-            envs = resources.env;
-            proc_macro_dylib_paths = resources.proc_dylib_paths;
-        }
        let mut pkg_by_id = FxHashMap::default();
        let mut packages = Arena::default();
@@ -265,7 +243,7 @@ impl CargoWorkspace {
        meta.packages.sort_by(|a, b| a.id.cmp(&b.id));
        for meta_pkg in meta.packages {
            let id = meta_pkg.id.clone();
-            inject_cargo_env(&meta_pkg, envs.entry(id).or_default());
+            let build_data = resources.get(&id).cloned().unwrap_or_default();
            let cargo_metadata::Package { id, edition, name, manifest_path, version, .. } =
                meta_pkg;
@@ -281,11 +259,9 @@ impl CargoWorkspace {
                is_member,
                edition,
                dependencies: Vec::new(),
-                features: Vec::new(),
+                features: meta_pkg.features.into_iter().collect(),
-                cfgs: cfgs.get(&id).cloned().unwrap_or_default(),
+                active_features: Vec::new(),
-                envs: envs.get(&id).cloned().unwrap_or_default(),
+                build_data,
-                out_dir: out_dir_by_id.get(&id).cloned(),
-                proc_macro_dylib_path: proc_macro_dylib_paths.get(&id).cloned(),
            });
            let pkg_data = &mut packages[pkg];
            pkg_by_id.insert(id, pkg);
@@ -328,7 +304,7 @@ impl CargoWorkspace {
                let dep = PackageDependency { name: dep_node.name, pkg };
                packages[source].dependencies.push(dep);
            }
-            packages[source].features.extend(node.features);
+            packages[source].active_features.extend(node.features);
        }
        let workspace_root = AbsPathBuf::assert(meta.workspace_root);
@@ -362,149 +338,3 @@ impl CargoWorkspace {
        self.packages.iter().filter(|(_, v)| v.name == name).count() == 1
    }
 }
-#[derive(Debug, Clone, Default)]
-pub(crate) struct ExternResources {
-    out_dirs: FxHashMap<PackageId, AbsPathBuf>,
-    proc_dylib_paths: FxHashMap<PackageId, AbsPathBuf>,
-    cfgs: FxHashMap<PackageId, Vec<CfgFlag>>,
-    env: FxHashMap<PackageId, Vec<(String, String)>>,
-}
-pub(crate) fn load_extern_resources(
-    cargo_toml: &Path,
-    cargo_features: &CargoConfig,
-    progress: &dyn Fn(String),
-) -> Result<ExternResources> {
-    let mut cmd = Command::new(toolchain::cargo());
-    cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"]).arg(cargo_toml);
-    // --all-targets includes tests, benches and examples in addition to the
-    // default lib and bins. This is an independent concept from the --targets
-    // flag below.
-    cmd.arg("--all-targets");
-    if let Some(target) = &cargo_features.target {
-        cmd.args(&["--target", target]);
-    }
-    if cargo_features.all_features {
-        cmd.arg("--all-features");
-    } else {
-        if cargo_features.no_default_features {
-            // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
-            // https://github.com/oli-obk/cargo_metadata/issues/79
-            cmd.arg("--no-default-features");
-        }
-        if !cargo_features.features.is_empty() {
-            cmd.arg("--features");
-            cmd.arg(cargo_features.features.join(" "));
-        }
-    }
-    cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
-    let mut child = cmd.spawn().map(JodChild)?;
-    let child_stdout = child.stdout.take().unwrap();
-    let stdout = BufReader::new(child_stdout);
-    let mut res = ExternResources::default();
-    for message in cargo_metadata::Message::parse_stream(stdout) {
-        if let Ok(message) = message {
-            match message {
-                Message::BuildScriptExecuted(BuildScript {
-                    package_id,
-                    out_dir,
-                    cfgs,
-                    env,
-                    ..
-                }) => {
-                    let cfgs = {
-                        let mut acc = Vec::new();
-                        for cfg in cfgs {
-                            match cfg.parse::<CfgFlag>() {
-                                Ok(it) => acc.push(it),
-                                Err(err) => {
-                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                                }
-                            };
-                        }
-                        acc
-                    };
-                    // cargo_metadata crate returns default (empty) path for
-                    // older cargos, which is not absolute, so work around that.
-                    if out_dir != PathBuf::default() {
-                        let out_dir = AbsPathBuf::assert(out_dir);
-                        res.out_dirs.insert(package_id.clone(), out_dir);
-                        res.cfgs.insert(package_id.clone(), cfgs);
-                    }
-                    res.env.insert(package_id, env);
-                }
-                Message::CompilerArtifact(message) => {
-                    progress(format!("metadata {}", message.target.name));
-                    if message.target.kind.contains(&"proc-macro".to_string()) {
-                        let package_id = message.package_id;
-                        // Skip rmeta file
-                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
-                        {
-                            let filename = AbsPathBuf::assert(filename.clone());
-                            res.proc_dylib_paths.insert(package_id, filename);
-                        }
-                    }
-                }
-                Message::CompilerMessage(message) => {
-                    progress(message.target.name.clone());
-                }
-                Message::Unknown => (),
-                Message::BuildFinished(_) => {}
-                Message::TextLine(_) => {}
-            }
-        }
-    }
-    Ok(res)
-}
-// FIXME: File a better way to know if it is a dylib
-fn is_dylib(path: &Path) -> bool {
-    match path.extension().and_then(OsStr::to_str).map(|it| it.to_string().to_lowercase()) {
-        None => false,
-        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
-    }
-}
-/// Recreates the compile-time environment variables that Cargo sets.
-///
-/// Should be synced with <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
-fn inject_cargo_env(package: &cargo_metadata::Package, env: &mut Vec<(String, String)>) {
-    // FIXME: Missing variables:
-    // CARGO, CARGO_PKG_HOMEPAGE, CARGO_CRATE_NAME, CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
-    let mut manifest_dir = package.manifest_path.clone();
-    manifest_dir.pop();
-    if let Some(cargo_manifest_dir) = manifest_dir.to_str() {
-        env.push(("CARGO_MANIFEST_DIR".into(), cargo_manifest_dir.into()));
-    }
-    env.push(("CARGO_PKG_VERSION".into(), package.version.to_string()));
-    env.push(("CARGO_PKG_VERSION_MAJOR".into(), package.version.major.to_string()));
-    env.push(("CARGO_PKG_VERSION_MINOR".into(), package.version.minor.to_string()));
-    env.push(("CARGO_PKG_VERSION_PATCH".into(), package.version.patch.to_string()));
-    let pre = package.version.pre.iter().map(|id| id.to_string()).format(".");
-    env.push(("CARGO_PKG_VERSION_PRE".into(), pre.to_string()));
-    let authors = package.authors.join(";");
-    env.push(("CARGO_PKG_AUTHORS".into(), authors));
-    env.push(("CARGO_PKG_NAME".into(), package.name.clone()));
-    env.push(("CARGO_PKG_DESCRIPTION".into(), package.description.clone().unwrap_or_default()));
-    //env.push(("CARGO_PKG_HOMEPAGE".into(), package.homepage.clone().unwrap_or_default()));
-    env.push(("CARGO_PKG_REPOSITORY".into(), package.repository.clone().unwrap_or_default()));
-    env.push(("CARGO_PKG_LICENSE".into(), package.license.clone().unwrap_or_default()));
-    let license_file =
-        package.license_file.as_ref().map(|buf| buf.display().to_string()).unwrap_or_default();
-    env.push(("CARGO_PKG_LICENSE_FILE".into(), license_file));
-}
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index aabb7a47d..525c336e6 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -5,6 +5,8 @@ mod cfg_flag;
 mod project_json;
 mod sysroot;
 mod workspace;
+mod rustc_cfg;
+mod build_data;
 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..bc5041e5a 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,14 +171,14 @@ 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;
                    let pkg_root = cargo[pkg].root().to_path_buf();
                    let mut include = vec![pkg_root.clone()];
-                    include.extend(cargo[pkg].out_dir.clone());
+                    include.extend(cargo[pkg].build_data.out_dir.clone());
                    let mut exclude = vec![pkg_root.join(".git")];
                    if 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();
@@ -453,26 +481,24 @@ fn add_target_crate_root(
    let edition = pkg.edition;
    let cfg_options = {
        let mut opts = cfg_options.clone();
-        for feature in pkg.features.iter() {
+        for feature in pkg.active_features.iter() {
            opts.insert_key_value("feature".into(), feature.into());
        }
-        opts.extend(pkg.cfgs.iter().cloned());
+        opts.extend(pkg.build_data.cfgs.iter().cloned());
        opts
    };
    let mut env = Env::default();
-    for (k, v) in &pkg.envs {
+    for (k, v) in &pkg.build_data.envs {
        env.set(k, v.clone());
    }
-    if let Some(out_dir) = &pkg.out_dir {
-        // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
-        if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
-            env.set("OUT_DIR", out_dir);
-        }
-    }
-    let proc_macro =
+    let proc_macro = pkg
-        pkg.proc_macro_dylib_path.as_ref().map(|it| proc_macro_loader(&it)).unwrap_or_default();
+        .build_data
+        .proc_macro_dylib_path
+        .as_ref()
+        .map(|it| proc_macro_loader(&it))
+        .unwrap_or_default();
    let display_name = CrateDisplayName::from_canonical_name(pkg.name.clone());
    let crate_id = crate_graph.add_crate_root(
@@ -490,11 +516,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 +560,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..268c00942 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -24,7 +24,7 @@ jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.86.0", features = ["proposed"] }
 parking_lot = "0.11.0"
-pico-args = "0.3.1"
+pico-args = "0.4.0"
 oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
@@ -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/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 0a471154e..7d917946e 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -109,7 +109,7 @@ impl Args {
        let mut matches = Arguments::from_env();
        if matches.contains("--version") {
-            matches.finish()?;
+            finish_args(matches)?;
            return Ok(Args {
                verbosity: Verbosity::Normal,
                log_file: None,
@@ -143,7 +143,7 @@ impl Args {
        let subcommand = match matches.subcommand()? {
            Some(it) => it,
            None => {
-                matches.finish()?;
+                finish_args(matches)?;
                return Ok(Args { verbosity, log_file, command: Command::RunServer });
            }
        };
@@ -160,7 +160,7 @@ impl Args {
                load_output_dirs: matches.contains("--load-output-dirs"),
                with_proc_macro: matches.contains("--with-proc-macro"),
                path: matches
-                    .free_from_str()?
+                    .opt_free_from_str()?
                    .ok_or_else(|| format_err!("expected positional argument"))?,
            }),
            "analysis-bench" => Command::Bench(BenchCmd {
@@ -187,21 +187,21 @@ impl Args {
                load_output_dirs: matches.contains("--load-output-dirs"),
                with_proc_macro: matches.contains("--with-proc-macro"),
                path: matches
-                    .free_from_str()?
+                    .opt_free_from_str()?
                    .ok_or_else(|| format_err!("expected positional argument"))?,
            }),
            "diagnostics" => Command::Diagnostics {
                load_output_dirs: matches.contains("--load-output-dirs"),
                with_proc_macro: matches.contains("--with-proc-macro"),
                path: matches
-                    .free_from_str()?
+                    .opt_free_from_str()?
                    .ok_or_else(|| format_err!("expected positional argument"))?,
            },
            "proc-macro" => Command::ProcMacro,
            "ssr" => Command::Ssr {
                rules: {
                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.free_from_str()? {
+                    while let Some(rule) = matches.opt_free_from_str()? {
                        acc.push(rule);
                    }
                    acc
@@ -211,7 +211,7 @@ impl Args {
                debug_snippet: matches.opt_value_from_str("--debug")?,
                patterns: {
                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.free_from_str()? {
+                    while let Some(rule) = matches.opt_free_from_str()? {
                        acc.push(rule);
                    }
                    acc
@@ -222,7 +222,14 @@ impl Args {
                return Ok(Args { verbosity, log_file: None, command: Command::Help });
            }
        };
-        matches.finish()?;
+        finish_args(matches)?;
        Ok(Args { verbosity, log_file, command })
    }
 }
+fn finish_args(args: Arguments) -> Result<()> {
+    if !args.finish().is_empty() {
+        bail!("Unused arguments.");
+    }
+    Ok(())
+}
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/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index fd1407e60..66416f709 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -2,6 +2,7 @@
 //! errors.
 use std::{
+    env,
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
 };
@@ -295,6 +296,10 @@ impl AnalysisStatsCmd {
            report_metric("total memory", memory.allocated.megabytes() as u64, "MB");
        }
+        if env::var("RA_COUNT").is_ok() {
+            eprintln!("{}", profile::countme::get_all());
+        }
        if self.memory_usage && verbosity.is_verbose() {
            print_memory_usage(host, vfs);
        }
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..42451cd2d 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))
 }
@@ -857,6 +858,23 @@ pub(crate) fn handle_formatting(
        RustfmtConfig::Rustfmt { extra_args } => {
            let mut cmd = process::Command::new(toolchain::rustfmt());
            cmd.args(extra_args);
+            // try to chdir to the file so we can respect `rustfmt.toml`
+            // FIXME: use `rustfmt --config-path` once
+            // https://github.com/rust-lang/rustfmt/issues/4660 gets fixed
+            match params.text_document.uri.to_file_path() {
+                Ok(mut path) => {
+                    // pop off file name
+                    if path.pop() && path.is_dir() {
+                        cmd.current_dir(path);
+                    }
+                }
+                Err(_) => {
+                    log::error!(
+                        "Unable to get file path for {}, rustfmt.toml might be ignored",
+                        params.text_document.uri
+                    );
+                }
+            }
            if let Some(&crate_id) = crate_ids.first() {
                // Assume all crates are in the same edition
                let edition = snap.analysis.crate_edition(crate_id)?;
@@ -1694,6 +1712,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 +1729,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/ssr/src/matching.rs b/crates/ssr/src/matching.rs
index 42d313f91..df013bae9 100644
--- a/crates/ssr/src/matching.rs
+++ b/crates/ssr/src/matching.rs
@@ -10,8 +10,11 @@ use hir::Semantics;
 use ide_db::base_db::FileRange;
 use rustc_hash::FxHashMap;
 use std::{cell::Cell, iter::Peekable};
-use syntax::ast::{AstNode, AstToken};
 use syntax::{ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken};
+use syntax::{
+    ast::{AstNode, AstToken},
+    SmolStr,
+};
 use test_utils::mark;
 // Creates a match error. If we're currently attempting to match some code that we thought we were
@@ -398,11 +401,11 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
        code: &SyntaxNode,
    ) -> Result<(), MatchFailed> {
        // Build a map keyed by field name.
-        let mut fields_by_name = FxHashMap::default();
+        let mut fields_by_name: FxHashMap<SmolStr, SyntaxNode> = FxHashMap::default();
        for child in code.children() {
            if let Some(record) = ast::RecordExprField::cast(child.clone()) {
                if let Some(name) = record.field_name() {
-                    fields_by_name.insert(name.text().clone(), child.clone());
+                    fields_by_name.insert(name.text().into(), child.clone());
                }
            }
        }
@@ -473,9 +476,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                        }
                        SyntaxElement::Node(n) => {
                            if let Some(first_token) = n.first_token() {
-                                if Some(first_token.text().as_str())
+                                if Some(first_token.text()) == next_pattern_token.as_deref() {
-                                    == next_pattern_token.as_deref()
-                                {
                                    if let Some(SyntaxElement::Node(p)) = pattern.next() {
                                        // We have a subtree that starts with the next token in our pattern.
                                        self.attempt_match_token_tree(phase, &p, &n)?;
diff --git a/crates/ssr/src/replacing.rs b/crates/ssr/src/replacing.rs
index 7e7ce37bd..06a94a46c 100644
--- a/crates/ssr/src/replacing.rs
+++ b/crates/ssr/src/replacing.rs
@@ -173,7 +173,7 @@ impl ReplacementRenderer<'_> {
                );
            }
        } else {
-            self.out.push_str(token.text().as_str());
+            self.out.push_str(token.text());
        }
    }
diff --git a/crates/ssr/src/resolving.rs b/crates/ssr/src/resolving.rs
index f5ceb5729..14e5a3b69 100644
--- a/crates/ssr/src/resolving.rs
+++ b/crates/ssr/src/resolving.rs
@@ -228,7 +228,7 @@ impl<'db> ResolutionScope<'db> {
                None,
                |_ty, assoc_item| {
                    let item_name = assoc_item.name(self.scope.db)?;
-                    if item_name.to_string().as_str() == name.text().as_str() {
+                    if item_name.to_string().as_str() == name.text() {
                        Some(hir::PathResolution::AssocItem(assoc_item))
                    } else {
                        None
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 1ff2559bb..73b121f8a 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -134,8 +134,10 @@ impl<'a> Iterator for LinesWithEnds<'a> {
 /// Returns `idx` such that:
 ///
+/// ```text
 ///     ∀ x in slice[..idx]:  pred(x)
 ///  && ∀ x in slice[idx..]: !pred(x)
+/// ```
 ///
 /// https://github.com/rust-lang/rust/issues/73831
 pub fn partition_point<T, P>(slice: &[T], mut pred: P) -> usize
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 52394b337..24298fbfa 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -12,15 +12,12 @@ doctest = false
 [dependencies]
 itertools = "0.10.0"
-rowan = "0.10.3"
+rowan = "0.12"
-rustc_lexer = { version = "697.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "700.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
 indexmap = "1.4.0"
-# This crate transitively depends on `smol_str` via `rowan`.
-# ideally, `serde` should be enabled by `rust-analyzer`, but we enable it here
-# to reduce number of compilations
 smol_str = { version = "0.1.15", features = ["serde"] }
 serde = { version = "1.0.106", features = ["derive"] }
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 827ae78f9..2ff92f9f6 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -4,6 +4,7 @@ use std::{
    fmt,
    hash::BuildHasherDefault,
    ops::{self, RangeInclusive},
+    ptr,
 };
 use indexmap::IndexMap;
@@ -171,7 +172,7 @@ pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
            && lhs.text_range().len() == rhs.text_range().len()
            && match (&lhs, &rhs) {
                (NodeOrToken::Node(lhs), NodeOrToken::Node(rhs)) => {
-                    lhs.green() == rhs.green() || lhs.text() == rhs.text()
+                    ptr::eq(lhs.green(), rhs.green()) || lhs.text() == rhs.text()
                }
                (NodeOrToken::Token(lhs), NodeOrToken::Token(rhs)) => lhs.text() == rhs.text(),
                _ => false,
@@ -566,7 +567,7 @@ impl<'a> SyntaxRewriter<'a> {
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().clone()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().to_owned()),
        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
    }
 }
@@ -624,7 +625,7 @@ fn position_of_child(parent: &SyntaxNode, child: SyntaxElement) -> usize {
 fn to_green_element(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => it.green().clone().into(),
+        NodeOrToken::Node(it) => it.green().to_owned().into(),
        NodeOrToken::Token(it) => it.green().clone().into(),
    }
 }
diff --git a/crates/syntax/src/ast.rs b/crates/syntax/src/ast.rs
index 83de067d9..a25ff655e 100644
--- a/crates/syntax/src/ast.rs
+++ b/crates/syntax/src/ast.rs
@@ -12,7 +12,7 @@ use std::marker::PhantomData;
 use crate::{
    syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken},
-    SmolStr, SyntaxKind,
+    SyntaxKind,
 };
 pub use self::{
@@ -54,7 +54,7 @@ pub trait AstToken {
    fn syntax(&self) -> &SyntaxToken;
-    fn text(&self) -> &SmolStr {
+    fn text(&self) -> &str {
        self.syntax().text()
    }
 }
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/make.rs b/crates/syntax/src/ast/make.rs
index 9ffc3ae11..b755c9692 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -478,7 +478,7 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green().clone())
+    SyntaxNode::new_root(n.green().to_owned())
 }
 pub mod tokens {
@@ -495,7 +495,7 @@ pub mod tokens {
            .syntax()
            .descendants_with_tokens()
            .filter_map(|it| it.into_token())
-            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == " ")
+            .find(|it| it.kind() == WHITESPACE && it.text() == " ")
            .unwrap()
    }
@@ -523,7 +523,7 @@ pub mod tokens {
            .syntax()
            .descendants_with_tokens()
            .filter_map(|it| it.into_token())
-            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n")
+            .find(|it| it.kind() == WHITESPACE && it.text() == "\n")
            .unwrap()
    }
@@ -533,7 +533,7 @@ pub mod tokens {
            .syntax()
            .descendants_with_tokens()
            .filter_map(|it| it.into_token())
-            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n\n")
+            .find(|it| it.kind() == WHITESPACE && it.text() == "\n\n")
            .unwrap()
    }
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index b8ce71d27..5c8cf900f 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -13,19 +13,19 @@ use crate::{
 };
 impl ast::Lifetime {
-    pub fn text(&self) -> &SmolStr {
+    pub fn text(&self) -> &str {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::Name {
-    pub fn text(&self) -> &SmolStr {
+    pub fn text(&self) -> &str {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::NameRef {
-    pub fn text(&self) -> &SmolStr {
+    pub fn text(&self) -> &str {
        text_of_first_token(self.syntax())
    }
@@ -34,7 +34,7 @@ impl ast::NameRef {
    }
 }
-fn text_of_first_token(node: &SyntaxNode) -> &SmolStr {
+fn text_of_first_token(node: &SyntaxNode) -> &str {
    node.green().children().next().and_then(|it| it.into_token()).unwrap().text()
 }
@@ -121,7 +121,7 @@ impl ast::Attr {
    pub fn simple_name(&self) -> Option<SmolStr> {
        let path = self.path()?;
        match (path.segment(), path.qualifier()) {
-            (Some(segment), None) => Some(segment.syntax().first_token()?.text().clone()),
+            (Some(segment), None) => Some(segment.syntax().first_token()?.text().into()),
            _ => None,
        }
    }
@@ -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/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 5e9620a40..5e07ec7d1 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -41,7 +41,7 @@ impl ast::Comment {
        match kind {
            CommentKind { shape, doc: Some(_) } => {
                let prefix = kind.prefix();
-                let text = &self.text().as_str()[prefix.len()..];
+                let text = &self.text()[prefix.len()..];
                let ws = text.chars().next().filter(|c| c.is_whitespace());
                let text = ws.map_or(text, |ws| &text[ws.len_utf8()..]);
                match shape {
@@ -156,13 +156,13 @@ impl ast::String {
    pub fn value(&self) -> Option<Cow<'_, str>> {
        if self.is_raw() {
-            let text = self.text().as_str();
+            let text = self.text();
            let text =
                &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
            return Some(Cow::Borrowed(text));
        }
-        let text = self.text().as_str();
+        let text = self.text();
        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
        let mut buf = String::new();
@@ -190,7 +190,7 @@ impl ast::String {
    }
    pub fn quote_offsets(&self) -> Option<QuoteOffsets> {
-        let text = self.text().as_str();
+        let text = self.text();
        let offsets = QuoteOffsets::new(text)?;
        let o = self.syntax().text_range().start();
        let offsets = QuoteOffsets {
@@ -560,7 +560,7 @@ impl HasFormatSpecifier for ast::String {
    fn char_ranges(
        &self,
    ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> {
-        let text = self.text().as_str();
+        let text = self.text();
        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
        let offset = self.text_range_between_quotes()?.start() - self.syntax().text_range().start();
@@ -590,7 +590,7 @@ impl ast::IntNumber {
    pub fn value(&self) -> Option<u128> {
        let token = self.syntax();
-        let mut text = token.text().as_str();
+        let mut text = token.text();
        if let Some(suffix) = self.suffix() {
            text = &text[..text.len() - suffix.len()]
        }
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index ea7482bb1..11294c5b2 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -56,9 +56,9 @@ pub use crate::{
 };
 pub use parser::{SyntaxKind, T};
 pub use rowan::{
-    Direction, GreenNode, NodeOrToken, SmolStr, SyntaxText, TextRange, TextSize, TokenAtOffset,
+    Direction, GreenNode, NodeOrToken, SyntaxText, TextRange, TextSize, TokenAtOffset, WalkEvent,
-    WalkEvent,
 };
+pub use smol_str::SmolStr;
 /// `Parse` is the result of the parsing: a syntax tree and a collection of
 /// errors.
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 76f01084c..3d637bf91 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -73,8 +73,7 @@ fn reparse_token<'node>(
                new_text.pop();
            }
-            let new_token =
+            let new_token = GreenToken::new(rowan::SyntaxKind(prev_token_kind.into()), &new_text);
-                GreenToken::new(rowan::SyntaxKind(prev_token_kind.into()), new_text.into());
            Some((
                prev_token.replace_with(new_token),
                new_err.into_iter().collect(),
diff --git a/crates/syntax/src/parsing/text_tree_sink.rs b/crates/syntax/src/parsing/text_tree_sink.rs
index ce27c3dd9..d5ddc076f 100644
--- a/crates/syntax/src/parsing/text_tree_sink.rs
+++ b/crates/syntax/src/parsing/text_tree_sink.rs
@@ -8,7 +8,7 @@ use crate::{
    ast,
    parsing::Token,
    syntax_node::GreenNode,
-    SmolStr, SyntaxError,
+    SyntaxError,
    SyntaxKind::{self, *},
    SyntaxTreeBuilder, TextRange, TextSize,
 };
@@ -135,7 +135,7 @@ impl<'a> TextTreeSink<'a> {
    fn do_token(&mut self, kind: SyntaxKind, len: TextSize, n_tokens: usize) {
        let range = TextRange::at(self.text_pos, len);
-        let text: SmolStr = self.text[range].into();
+        let text = &self.text[range];
        self.text_pos += len;
        self.token_pos += n_tokens;
        self.inner.token(kind, text);
diff --git a/crates/syntax/src/syntax_node.rs b/crates/syntax/src/syntax_node.rs
index cc30138fa..8f643b228 100644
--- a/crates/syntax/src/syntax_node.rs
+++ b/crates/syntax/src/syntax_node.rs
@@ -8,7 +8,7 @@
 use rowan::{GreenNodeBuilder, Language};
-use crate::{Parse, SmolStr, SyntaxError, SyntaxKind, TextSize};
+use crate::{Parse, SyntaxError, SyntaxKind, TextSize};
 pub(crate) use rowan::{GreenNode, GreenToken, NodeOrToken};
@@ -53,7 +53,7 @@ impl SyntaxTreeBuilder {
        Parse::new(green, errors)
    }
-    pub fn token(&mut self, kind: SyntaxKind, text: SmolStr) {
+    pub fn token(&mut self, kind: SyntaxKind, text: &str) {
        let kind = RustLanguage::kind_to_raw(kind);
        self.inner.token(kind, text)
    }
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 7901580ee..7694e8834 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -116,7 +116,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
    }
    let token = literal.token();
-    let text = token.text().as_str();
+    let text = token.text();
    // FIXME: lift this lambda refactor to `fn` (https://github.com/rust-analyzer/rust-analyzer/pull/2834#discussion_r366199205)
    let mut push_err = |prefix_len, (off, err): (usize, unescape::EscapeError)| {
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/docs/dev/README.md b/docs/dev/README.md
index dd2bfc493..24197b332 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -251,6 +251,9 @@ RA_PROFILE=*@3>10        // dump everything, up to depth 3, if it takes more tha
 In particular, I have `export RA_PROFILE='*>10'` in my shell profile.
+We also have a "counting" profiler which counts number of instances of popular structs.
+It is enabled by `RA_COUNT=1`.
 To measure time for from-scratch analysis, use something like this:
 ```
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 21330948b..7e6cd49e0 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -6,6 +6,9 @@ Our approach to "clean code" is two-fold:
 It is explicitly OK for a reviewer to flag only some nits in the PR, and then send a follow-up cleanup PR for things which are easier to explain by example, cc-ing the original author.
 Sending small cleanup PRs (like renaming a single local variable) is encouraged.
+When reviewing pull requests prefer extending this document to leaving
+non-reusable comments on the pull request itself.
 # General
 ## Scale of Changes
@@ -280,6 +283,9 @@ Prefer `Default` even it has to be implemented manually.
 **Rationale:** less typing in the common case, uniformity.
+Use `Vec::new` rather than `vec![]`. **Rationale:** uniformity, strength
+reduction.
 ## Functions Over Objects
 Avoid creating "doer" objects.
@@ -372,6 +378,15 @@ This allows for exceptionally good performance, but leads to increased compile t
 Runtime performance obeys 80%/20% rule -- only a small fraction of code is hot.
 Compile time **does not** obey this rule -- all code has to be compiled.
+## Appropriate String Types
+When interfacing with OS APIs, use `OsString`, even if the original source of
+data is utf-8 encoded. **Rationale:** cleanly delineates the boundary when the
+data goes into the OS-land.
+Use `AbsPathBuf` and `AbsPath` over `std::Path`. **Rationale:** rust-analyzer is
+a long-lived process which handles several projects at the same time. It is
+important not to leak cwd by accident.
 # Premature Pessimization
@@ -418,12 +433,44 @@ fn frobnicate(s: &str) {
 **Rationale:** reveals the costs.
 It is also more efficient when the caller already owns the allocation.
-## Collection types
+## Collection Types
 Prefer `rustc_hash::FxHashMap` and `rustc_hash::FxHashSet` instead of the ones in `std::collections`.
 **Rationale:** they use a hasher that's significantly faster and using them consistently will reduce code size by some small amount.
+## Avoid Intermediate Collections
+When writing a recursive function to compute a sets of things, use an accumulator parameter instead of returning a fresh collection.
+Accumulator goes first in the list of arguments.
+```rust
+// GOOD
+pub fn reachable_nodes(node: Node) -> FxHashSet<Node> {
+    let mut res = FxHashSet::default();
+    go(&mut res, node);
+    res
+}
+fn go(acc: &mut FxHashSet<Node>, node: Node) {
+    acc.insert(node);
+    for n in node.neighbors() {
+        go(acc, n);
+    }
+}
+// BAD
+pub fn reachable_nodes(node: Node) -> FxHashSet<Node> {
+    let mut res = FxHashSet::default();
+    res.insert(node);
+    for n in node.neighbors() {
+        res.extend(reachable_nodes(n));
+    }
+    res
+}
+```
+**Rational:** re-use allocations, accumulator style is more concise for complex cases.
 # Style
 ## Order of Imports
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 1bb9222d7..4e6b439fd 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -12,10 +12,10 @@ doctest = false
 [dependencies]
 anyhow = "1.0.26"
 flate2 = "1.0"
-pico-args = "0.3.1"
+pico-args = "0.4.0"
 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/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index 6e18a50a6..51f58180c 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -4,7 +4,7 @@ use std::{fmt, path::Path};
 use crate::{
    codegen::{self, extract_comment_blocks_with_empty_lines, reformat, Location, Mode, PREAMBLE},
-    project_root, rust_files, Result,
+    project_root, rust_files_in, Result,
 };
 pub fn generate_assists_tests(mode: Mode) -> Result<()> {
@@ -32,7 +32,7 @@ struct Assist {
 impl Assist {
    fn collect() -> Result<Vec<Assist>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root().join("crates/assists/src/handlers")) {
+        for path in rust_files_in(&project_root().join("crates/assists/src/handlers")) {
            collect_file(&mut res, path.as_path())?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
diff --git a/xtask/src/codegen/gen_diagnostic_docs.rs b/xtask/src/codegen/gen_diagnostic_docs.rs
index 00aaea5b7..7c14d4a07 100644
--- a/xtask/src/codegen/gen_diagnostic_docs.rs
+++ b/xtask/src/codegen/gen_diagnostic_docs.rs
@@ -27,7 +27,7 @@ struct Diagnostic {
 impl Diagnostic {
    fn collect() -> Result<Vec<Diagnostic>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root()) {
+        for path in rust_files() {
            collect_file(&mut res, path)?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 065dd33f1..61081063b 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -26,7 +26,7 @@ struct Feature {
 impl Feature {
    fn collect() -> Result<Vec<Feature>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root()) {
+        for path in rust_files() {
            collect_file(&mut res, path)?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
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/lib.rs b/xtask/src/lib.rs
index babec2dbd..16b06b853 100644
--- a/xtask/src/lib.rs
+++ b/xtask/src/lib.rs
@@ -34,7 +34,11 @@ pub fn project_root() -> PathBuf {
    .to_path_buf()
 }
-pub fn rust_files(path: &Path) -> impl Iterator<Item = PathBuf> {
+pub fn rust_files() -> impl Iterator<Item = PathBuf> {
+    rust_files_in(&project_root().join("crates"))
+}
+pub fn rust_files_in(path: &Path) -> impl Iterator<Item = PathBuf> {
    let iter = WalkDir::new(path);
    return iter
        .into_iter()
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index dec48629c..5a99f4a76 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -10,6 +10,7 @@
 use std::env;
+use anyhow::bail;
 use codegen::CodegenCmd;
 use pico_args::Arguments;
 use xshell::{cmd, cp, pushd};
@@ -49,7 +50,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,12 +67,17 @@ 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")?;
-            args.finish()?;
+            finish_args(args)?;
            InstallCmd {
                client: if server { None } else { Some(client_opt.unwrap_or_default()) },
@@ -80,53 +87,53 @@ FLAGS:
        }
        "codegen" => {
            let features = args.contains("--features");
-            args.finish()?;
+            finish_args(args)?;
            CodegenCmd { features }.run()
        }
        "format" => {
-            args.finish()?;
+            finish_args(args)?;
            run_rustfmt(Mode::Overwrite)
        }
        "install-pre-commit-hook" => {
-            args.finish()?;
+            finish_args(args)?;
            pre_commit::install_hook()
        }
        "lint" => {
-            args.finish()?;
+            finish_args(args)?;
            run_clippy()
        }
        "fuzz-tests" => {
-            args.finish()?;
+            finish_args(args)?;
            run_fuzzer()
        }
        "pre-cache" => {
-            args.finish()?;
+            finish_args(args)?;
            PreCacheCmd.run()
        }
        "release" => {
            let dry_run = args.contains("--dry-run");
-            args.finish()?;
+            finish_args(args)?;
            ReleaseCmd { dry_run }.run()
        }
        "promote" => {
            let dry_run = args.contains("--dry-run");
-            args.finish()?;
+            finish_args(args)?;
            PromoteCmd { dry_run }.run()
        }
        "dist" => {
            let nightly = args.contains("--nightly");
            let client_version: Option<String> = args.opt_value_from_str("--client")?;
-            args.finish()?;
+            finish_args(args)?;
            DistCmd { nightly, client_version }.run()
        }
        "metrics" => {
            let dry_run = args.contains("--dry-run");
-            args.finish()?;
+            finish_args(args)?;
            MetricsCmd { dry_run }.run()
        }
        "bb" => {
-            let suffix: String = args.free_from_str()?.unwrap();
+            let suffix: String = args.free_from_str()?;
-            args.finish()?;
+            finish_args(args)?;
            cmd!("cargo build --release").run()?;
            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", suffix))?;
            Ok(())
@@ -155,3 +162,10 @@ SUBCOMMANDS:
        }
    }
 }
+fn finish_args(args: Arguments) -> Result<()> {
+    if !args.finish().is_empty() {
+        bail!("Unused arguments.");
+    }
+    Ok(())
+}
diff --git a/xtask/tests/tidy.rs b/xtask/tests/tidy.rs
index 6abad189a..9a6933b09 100644
--- a/xtask/tests/tidy.rs
+++ b/xtask/tests/tidy.rs
@@ -82,7 +82,7 @@ Please adjust docs/dev/lsp-extensions.md.
 #[test]
 fn rust_files_are_tidy() {
    let mut tidy_docs = TidyDocs::default();
-    for path in rust_files(&project_root().join("crates")) {
+    for path in rust_files() {
        let text = read_file(&path).unwrap();
        check_todo(&path, &text);
        check_dbg(&path, &text);