50 files changed, 2092 insertions, 504 deletions
diff --git a/.github/ISSUE_TEMPLATE/critical_nightly_regression.md b/.github/ISSUE_TEMPLATE/critical_nightly_regression.md
new file mode 100644
index 000000000..a0b1627d7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/critical_nightly_regression.md
@@ -0,0 +1,17 @@
+---
+name: Critical Nightly Regression
+about: You are using nightly rust-analyzer and the latest version is unusable.
+title: ''
+labels: ''
+assignees: 'matklad'
+---
+<!--
+Troubleshooting guide: https://rust-analyzer.github.io/manual.html#troubleshooting
+Please try to provide information which will help us to fix the issue faster. Minimal reproducible examples with few dependencies are especially lovely <3.
+-->
+This is a serious regression in nightly and it's important to fix it before the next release.
+@matklad, please take a look.
diff --git a/Cargo.lock b/Cargo.lock
index 1bb66c66e..907973412 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -72,9 +72,9 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 [[package]]
 name = "backtrace"
-version = "0.3.56"
+version = "0.3.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc"
+checksum = "78ed203b9ba68b242c62b3fb7480f589dd49829be1edb3fe8fc8b4ffda2dcb8d"
 dependencies = [
 "addr2line",
 "cfg-if",
@@ -168,9 +168,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "chalk-derive"
-version = "0.60.0"
+version = "0.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab0f74445d4fbeaf0217bc1d23978cc73b95b28e8a738b81894580dd646822d2"
+checksum = "d9acf2a9eab79ae7d44cd77ad86a8b1569d7a5e6d9a7db4a0a57a7344dd82c24"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -180,9 +180,9 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
-version = "0.60.0"
+version = "0.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "294b1fc6210a5b3bd06c1d01dda48a581e2cafec80b8d659139ce45456644be2"
+checksum = "877661627f54ba3666a72943c43b326cb170d60899e50a8426111e7a657ff032"
 dependencies = [
 "bitflags",
 "chalk-derive",
@@ -191,9 +191,9 @@ dependencies = [
 [[package]]
 name = "chalk-recursive"
-version = "0.60.0"
+version = "0.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9386936070be4545bfa22b094b7065af79aa2aeaccc945438f1c5ffe74c30a"
+checksum = "072ffcf17243c2aa3e4b9ea6de3d29e7ef64cfdb0ceccaa431965070a1dc1475"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -204,9 +204,9 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
-version = "0.60.0"
+version = "0.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c12a1ec7e850b50a049f27ef9cf5df3056bbd1acbb3eeb44d024e501a641f3a"
+checksum = "97d4920c9ef2b26dd0b98ffdf070e27fa31e0b6f637463132083cee597e3d326"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -396,6 +396,7 @@ dependencies = [
 "crossbeam-channel",
 "jod-thread",
 "log",
+ "serde",
 "serde_json",
 "stdx",
 "toolchain",
@@ -684,9 +685,9 @@ dependencies = [
 [[package]]
 name = "idna"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89829a5d69c23d348314a7ac337fe39173b61149a9864deabd260983aed48c21"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
 dependencies = [
 "matches",
 "unicode-bidi",
@@ -1174,6 +1175,7 @@ dependencies = [
 "log",
 "memmap",
 "object",
+ "profile",
 "serde",
 "serde_json",
 "snap",
@@ -1292,9 +1294,9 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9"
+checksum = "8270314b5ccceb518e7e578952f0b72b88222d02e8f77f5ecf7abbb673539041"
 dependencies = [
 "bitflags",
 ]
@@ -1391,9 +1393,9 @@ dependencies = [
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "714.0.0"
+version = "716.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35856f140bed0dc7c7d6ba2134099d337377a3a4e11bfc79bccabf1fd4c9d42"
+checksum = "12eac7554c1d3f49f105f14d53c0f3402220e875983113562701d8e597a0995c"
 dependencies = [
 "unicode-xid",
 ]
@@ -1573,6 +1575,9 @@ version = "0.0.0"
 dependencies = [
 "always-assert",
 "backtrace",
+ "libc",
+ "miow",
+ "winapi",
 ]
 [[package]]
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 07628935f..0ef77ef5d 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -239,6 +239,7 @@ impl CrateGraph {
        name: CrateName,
        to: CrateId,
    ) -> Result<(), CyclicDependenciesError> {
+        let _p = profile::span("add_dep");
        if self.dfs_find(from, to, &mut FxHashSet::default()) {
            return Err(CyclicDependenciesError {
                from: (from, self[from].display_name.clone()),
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 2a1a21b28..18b9ce7df 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -13,6 +13,7 @@ doctest = false
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
 cargo_metadata = "0.13"
+serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index e2a59497a..1682d8bde 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -4,13 +4,14 @@
 use std::{
    fmt,
-    io::{self, BufReader},
+    io::{self, BufRead, BufReader},
    path::PathBuf,
    process::{self, Command, Stdio},
    time::Duration,
 };
 use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
+use serde::Deserialize;
 use stdx::JodChild;
 pub use cargo_metadata::diagnostic::{
@@ -128,7 +129,7 @@ struct FlycheckActor {
 enum Event {
    Restart(Restart),
-    CheckEvent(Option<cargo_metadata::Message>),
+    CheckEvent(Option<CargoMessage>),
 }
 impl FlycheckActor {
@@ -180,21 +181,16 @@ impl FlycheckActor {
                    self.progress(Progress::DidFinish(res));
                }
                Event::CheckEvent(Some(message)) => match message {
-                    cargo_metadata::Message::CompilerArtifact(msg) => {
+                    CargoMessage::CompilerArtifact(msg) => {
                        self.progress(Progress::DidCheckCrate(msg.target.name));
                    }
-                    cargo_metadata::Message::CompilerMessage(msg) => {
+                    CargoMessage::Diagnostic(msg) => {
                        self.send(Message::AddDiagnostic {
                            workspace_root: self.workspace_root.clone(),
-                            diagnostic: msg.message,
+                            diagnostic: msg,
                        });
                    }
-                    cargo_metadata::Message::BuildScriptExecuted(_)
-                    | cargo_metadata::Message::BuildFinished(_)
-                    | cargo_metadata::Message::TextLine(_)
-                    | _ => {}
                },
            }
        }
@@ -261,7 +257,7 @@ struct CargoHandle {
    child: JodChild,
    #[allow(unused)]
    thread: jod_thread::JoinHandle<io::Result<bool>>,
-    receiver: Receiver<cargo_metadata::Message>,
+    receiver: Receiver<CargoMessage>,
 }
 impl CargoHandle {
@@ -294,14 +290,11 @@ impl CargoHandle {
 struct CargoActor {
    child_stdout: process::ChildStdout,
-    sender: Sender<cargo_metadata::Message>,
+    sender: Sender<CargoMessage>,
 }
 impl CargoActor {
-    fn new(
+    fn new(child_stdout: process::ChildStdout, sender: Sender<CargoMessage>) -> CargoActor {
-        child_stdout: process::ChildStdout,
-        sender: Sender<cargo_metadata::Message>,
-    ) -> CargoActor {
        CargoActor { child_stdout, sender }
    }
    fn run(self) -> io::Result<bool> {
@@ -315,7 +308,7 @@ impl CargoActor {
        // erroneus output.
        let stdout = BufReader::new(self.child_stdout);
        let mut read_at_least_one_message = false;
-        for message in cargo_metadata::Message::parse_stream(stdout) {
+        for message in stdout.lines() {
            let message = match message {
                Ok(message) => message,
                Err(err) => {
@@ -326,13 +319,44 @@ impl CargoActor {
            read_at_least_one_message = true;
-            // Skip certain kinds of messages to only spend time on what's useful
+            // Try to deserialize a message from Cargo or Rustc.
-            match &message {
+            let mut deserializer = serde_json::Deserializer::from_str(&message);
-                cargo_metadata::Message::CompilerArtifact(artifact) if artifact.fresh => (),
+            deserializer.disable_recursion_limit();
-                cargo_metadata::Message::BuildScriptExecuted(_) => (),
+            if let Ok(message) = JsonMessage::deserialize(&mut deserializer) {
-                _ => self.sender.send(message).unwrap(),
+                match message {
+                    // Skip certain kinds of messages to only spend time on what's useful
+                    JsonMessage::Cargo(message) => match message {
+                        cargo_metadata::Message::CompilerArtifact(artifact) if !artifact.fresh => {
+                            self.sender.send(CargoMessage::CompilerArtifact(artifact)).unwrap()
+                        }
+                        cargo_metadata::Message::CompilerMessage(msg) => {
+                            self.sender.send(CargoMessage::Diagnostic(msg.message)).unwrap()
+                        }
+                        cargo_metadata::Message::CompilerArtifact(_)
+                        | cargo_metadata::Message::BuildScriptExecuted(_)
+                        | cargo_metadata::Message::BuildFinished(_)
+                        | cargo_metadata::Message::TextLine(_)
+                        | _ => (),
+                    },
+                    JsonMessage::Rustc(message) => {
+                        self.sender.send(CargoMessage::Diagnostic(message)).unwrap()
+                    }
+                }
            }
        }
        Ok(read_at_least_one_message)
    }
 }
+enum CargoMessage {
+    CompilerArtifact(cargo_metadata::Artifact),
+    Diagnostic(Diagnostic),
+}
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum JsonMessage {
+    Cargo(cargo_metadata::Message),
+    Rustc(Diagnostic),
+}
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 63f5fe88d..3e8f16306 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -40,6 +40,14 @@ fn block_def_map_at(ra_fixture: &str) -> String {
    module.def_map(&db).dump(&db)
 }
+fn check_block_scopes_at(ra_fixture: &str, expect: Expect) {
+    let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
+    let module = db.module_at_position(position);
+    let actual = module.def_map(&db).dump_block_scopes(&db);
+    expect.assert_eq(&actual);
+}
 fn check_at(ra_fixture: &str, expect: Expect) {
    let actual = block_def_map_at(ra_fixture);
    expect.assert_eq(&actual);
diff --git a/crates/hir_def/src/body/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
index 3b6ba4cde..bc3d0f138 100644
--- a/crates/hir_def/src/body/tests/block.rs
+++ b/crates/hir_def/src/body/tests/block.rs
@@ -134,6 +134,30 @@ struct Struct {}
 }
 #[test]
+fn nested_module_scoping() {
+    check_block_scopes_at(
+        r#"
+fn f() {
+    mod module {
+        struct Struct {}
+        fn f() {
+            use self::Struct;
+            $0
+        }
+    }
+}
+    "#,
+        expect![[r#"
+            BlockId(1) in ModuleId { krate: CrateId(0), block: Some(BlockId(0)), local_id: Idx::<ModuleData>(0) }
+            BlockId(0) in ModuleId { krate: CrateId(0), block: None, local_id: Idx::<ModuleData>(0) }
+            crate scope
+        "#]],
+    );
+    // FIXME: The module nesting here is wrong!
+    // The first block map should be located in module #1 (`mod module`), not #0 (BlockId(0) root module)
+}
+#[test]
 fn legacy_macro_items() {
    // Checks that legacy-scoped `macro_rules!` from parent namespaces are resolved and expanded
    // correctly.
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 16a94a058..eaeca01bd 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -196,13 +196,6 @@ impl ItemTree {
        self.raw_attrs(of).clone().filter(db, krate)
    }
-    pub fn all_inner_items(&self) -> impl Iterator<Item = ModItem> + '_ {
-        match &self.data {
-            Some(data) => Some(data.inner_items.values().flatten().copied()).into_iter().flatten(),
-            None => None.into_iter().flatten(),
-        }
-    }
    pub fn inner_items_of_block(&self, block: FileAstId<ast::BlockExpr>) -> &[ModItem] {
        match &self.data {
            Some(data) => data.inner_items.get(&block).map(|it| &**it).unwrap_or(&[]),
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 542f190a1..ba027c44a 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -410,6 +410,20 @@ impl DefMap {
        }
    }
+    pub fn dump_block_scopes(&self, db: &dyn DefDatabase) -> String {
+        let mut buf = String::new();
+        let mut arc;
+        let mut current_map = self;
+        while let Some(block) = &current_map.block {
+            format_to!(buf, "{:?} in {:?}\n", block.block, block.parent);
+            arc = block.parent.def_map(db);
+            current_map = &*arc;
+        }
+        format_to!(buf, "crate scope\n");
+        buf
+    }
    fn shrink_to_fit(&mut self) {
        // Exhaustive match to require handling new fields.
        let Self {
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index abc0e7532..66b3418f2 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -18,9 +18,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.60", default-features = false }
+chalk-solve = { version = "0.64", default-features = false }
-chalk-ir = "0.60"
+chalk-ir = "0.64"
-chalk-recursive = "0.60"
+chalk-recursive = "0.64"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/ide/src/prime_caches.rs b/crates/ide/src/prime_caches.rs
index ea0acfaa0..03597f507 100644
--- a/crates/ide/src/prime_caches.rs
+++ b/crates/ide/src/prime_caches.rs
@@ -27,6 +27,7 @@ pub(crate) fn prime_caches(db: &RootDatabase, cb: &(dyn Fn(PrimeCachesProgress)
    let topo = &graph.crates_in_topological_order();
    cb(PrimeCachesProgress::Started);
+    let _d = stdx::defer(|| cb(PrimeCachesProgress::Finished));
    // FIXME: This would be easy to parallelize, since it's in the ideal ordering for that.
    // Unfortunately rayon prevents panics from propagation out of a `scope`, which breaks
@@ -41,6 +42,4 @@ pub(crate) fn prime_caches(db: &RootDatabase, cb: &(dyn Fn(PrimeCachesProgress)
        });
        db.crate_def_map(*krate);
    }
-    cb(PrimeCachesProgress::Finished);
 }
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 18552459b..8731699dc 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -1,6 +1,6 @@
 //! Computes color for a single element.
-use hir::{AsAssocItem, AssocItemContainer, Semantics, VariantDef};
+use hir::{AsAssocItem, Semantics};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
    RootDatabase, SymbolKind,
@@ -45,28 +45,26 @@ pub(super) fn element(
            };
            match name_kind {
-                Some(NameClass::ExternCrate(_)) => HlTag::Symbol(SymbolKind::Module).into(),
+                Some(NameClass::ExternCrate(_)) => SymbolKind::Module.into(),
                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
                    if let Definition::Field(field) = field_ref {
-                        if let VariantDef::Union(_) = field.parent_def(db) {
+                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
                            h |= HlMod::Unsafe;
                        }
                    }
                    h
                }
                None => highlight_name_by_syntax(name) | HlMod::Definition,
            }
        }
        // Highlight references like the definitions they resolve to
        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
            // even though we track whether we are in an attribute or not we still need this special case
            // as otherwise we would emit unresolved references for name refs inside attributes
-            Highlight::from(HlTag::Symbol(SymbolKind::Function))
+            SymbolKind::Function.into()
        }
        NAME_REF => {
            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
@@ -74,7 +72,7 @@ pub(super) fn element(
                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::ExternCrate(_) => SymbolKind::Module.into(),
                        NameRefClass::Definition(def) => {
                            if let Definition::Local(local) = &def {
                                if let Some(name) = local.name(db) {
@@ -95,7 +93,7 @@ pub(super) fn element(
                            if let Some(parent) = name_ref.syntax().parent() {
                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
                                    if let Definition::Field(field) = def {
-                                        if let VariantDef::Union(_) = field.parent_def(db) {
+                                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
                                            h |= HlMod::Unsafe;
                                        }
                                    }
@@ -104,9 +102,7 @@ pub(super) fn element(
                            h
                        }
-                        NameRefClass::FieldShorthand { .. } => {
+                        NameRefClass::FieldShorthand { .. } => SymbolKind::Field.into(),
-                            HlTag::Symbol(SymbolKind::Field).into()
-                        }
                    },
                    None if syntactic_name_ref_highlighting => {
                        highlight_name_ref_by_syntax(name_ref, sema)
@@ -114,7 +110,7 @@ pub(super) fn element(
                    None => HlTag::UnresolvedReference.into(),
                };
                if h.tag == HlTag::Symbol(SymbolKind::Module) && is_self {
-                    HlTag::Symbol(SymbolKind::SelfParam).into()
+                    SymbolKind::SelfParam.into()
                } else {
                    h
                }
@@ -135,7 +131,7 @@ pub(super) fn element(
        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
        BYTE => HlTag::ByteLiteral.into(),
        CHAR => HlTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HlTag::Operator(HlOperator::Other)) | HlMod::ControlFlow,
+        QUESTION => HlTag::Operator(HlOperator::Other) | HlMod::ControlFlow,
        LIFETIME => {
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
@@ -143,44 +139,31 @@ pub(super) fn element(
                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
-                    _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
+                    _ => SymbolKind::LifetimeParam.into(),
                },
-                _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
+                _ => Highlight::from(SymbolKind::LifetimeParam) | HlMod::Definition,
            }
        }
        p if p.is_punct() => match p {
-            T![&] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+            T![&] if parent_matches::<ast::BinExpr>(&element) => HlOperator::Bitwise.into(),
-                HlTag::Operator(HlOperator::Bitwise).into()
-            }
            T![&] => {
                let h = HlTag::Operator(HlOperator::Other).into();
                let is_unsafe = element
                    .parent()
                    .and_then(ast::RefExpr::cast)
-                    .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
+                    .map_or(false, |ref_expr| sema.is_unsafe_ref_expr(&ref_expr));
-                    .unwrap_or(false);
                if is_unsafe {
                    h | HlMod::Unsafe
                } else {
                    h
                }
            }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            T![!] if parent_matches::<ast::MacroCall>(&element) => SymbolKind::Macro.into(),
-            }
+            T![!] if parent_matches::<ast::NeverType>(&element) => HlTag::BuiltinType.into(),
-            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+            T![!] if parent_matches::<ast::PrefixExpr>(&element) => HlOperator::Logical.into(),
-                HlTag::Symbol(SymbolKind::Macro).into()
+            T![*] if parent_matches::<ast::PtrType>(&element) => HlTag::Keyword.into(),
-            }
+            T![*] if parent_matches::<ast::PrefixExpr>(&element) => {
-            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
-                HlTag::BuiltinType.into()
-            }
-            T![!] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HlTag::Operator(HlOperator::Logical).into()
-            }
-            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
-                HlTag::Keyword.into()
-            }
-            T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
                let expr = prefix_expr.expr()?;
@@ -188,12 +171,12 @@ pub(super) fn element(
                if ty.is_raw_ptr() {
                    HlTag::Operator(HlOperator::Other) | HlMod::Unsafe
                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HlTag::Operator(HlOperator::Other).into()
+                    HlOperator::Other.into()
                } else {
-                    HlTag::Punctuation(HlPunct::Other).into()
+                    HlPunct::Other.into()
                }
            }
-            T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+            T![-] if parent_matches::<ast::PrefixExpr>(&element) => {
                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
                let expr = prefix_expr.expr()?;
@@ -203,41 +186,31 @@ pub(super) fn element(
                }
                .into()
            }
-            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+            _ if parent_matches::<ast::PrefixExpr>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
-            }
            T![+] | T![-] | T![*] | T![/] | T![+=] | T![-=] | T![*=] | T![/=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Arithmetic).into()
+                HlOperator::Arithmetic.into()
            }
            T![|] | T![&] | T![!] | T![^] | T![|=] | T![&=] | T![^=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Bitwise).into()
+                HlOperator::Bitwise.into()
            }
-            T![&&] | T![||] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+            T![&&] | T![||] if parent_matches::<ast::BinExpr>(&element) => {
-                HlTag::Operator(HlOperator::Logical).into()
+                HlOperator::Logical.into()
            }
            T![>] | T![<] | T![==] | T![>=] | T![<=] | T![!=]
-                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+                if parent_matches::<ast::BinExpr>(&element) =>
            {
-                HlTag::Operator(HlOperator::Comparison).into()
+                HlOperator::Comparison.into()
-            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
-                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
+            _ if parent_matches::<ast::BinExpr>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            _ if parent_matches::<ast::RangeExpr>(&element) => HlOperator::Other.into(),
-            }
+            _ if parent_matches::<ast::RangePat>(&element) => HlOperator::Other.into(),
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
+            _ if parent_matches::<ast::RestPat>(&element) => HlOperator::Other.into(),
-                HlTag::Operator(HlOperator::Other).into()
+            _ if parent_matches::<ast::Attr>(&element) => HlTag::Attribute.into(),
-            }
+            kind => match kind {
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
-                HlTag::Operator(HlOperator::Other).into()
-            }
-            _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
-            kind => HlTag::Punctuation(match kind {
                T!['['] | T![']'] => HlPunct::Bracket,
                T!['{'] | T!['}'] => HlPunct::Brace,
                T!['('] | T![')'] => HlPunct::Parenthesis,
@@ -247,22 +220,24 @@ pub(super) fn element(
                T![;] => HlPunct::Semi,
                T![.] => HlPunct::Dot,
                _ => HlPunct::Other,
-            })
+            }
            .into(),
        },
        k if k.is_keyword() => {
            let h = Highlight::new(HlTag::Keyword);
            match k {
-                T![break]
+                T![await]
+                | T![break]
                | T![continue]
                | T![else]
                | T![if]
+                | T![in]
                | T![loop]
                | T![match]
                | T![return]
                | T![while]
-                | T![in] => h | HlMod::ControlFlow,
+                | T![yield] => h | HlMod::ControlFlow,
                T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
                T![unsafe] => h | HlMod::Unsafe,
                T![true] | T![false] => HlTag::BoolLiteral.into(),
@@ -301,7 +276,6 @@ pub(super) fn element(
        hash((name, shadow_count))
    }
 }
 fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
    match def {
        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
@@ -317,12 +291,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                    }
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -342,12 +316,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if let Some(item) = konst.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -361,12 +335,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if let Some(item) = type_.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
-                        AssocItemContainer::Impl(i) => {
+                        hir::AssocItemContainer::Impl(i) => {
                            if i.trait_(db).is_some() {
                                h |= HlMod::Trait;
                            }
                        }
-                        AssocItemContainer::Trait(_t) => {
+                        hir::AssocItemContainer::Trait(_t) => {
                            h |= HlMod::Trait;
                        }
                    }
@@ -425,7 +399,7 @@ fn highlight_method_call(
    method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
    let func = sema.resolve_method_call(&method_call)?;
-    let mut h = HlTag::Symbol(SymbolKind::Function).into();
+    let mut h = SymbolKind::Function.into();
    h |= HlMod::Associated;
    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
        h |= HlMod::Unsafe;
@@ -461,20 +435,20 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
    };
    let tag = match parent.kind() {
-        STRUCT => HlTag::Symbol(SymbolKind::Struct),
+        STRUCT => SymbolKind::Struct,
-        ENUM => HlTag::Symbol(SymbolKind::Enum),
+        ENUM => SymbolKind::Enum,
-        VARIANT => HlTag::Symbol(SymbolKind::Variant),
+        VARIANT => SymbolKind::Variant,
-        UNION => HlTag::Symbol(SymbolKind::Union),
+        UNION => SymbolKind::Union,
-        TRAIT => HlTag::Symbol(SymbolKind::Trait),
+        TRAIT => SymbolKind::Trait,
-        TYPE_ALIAS => HlTag::Symbol(SymbolKind::TypeAlias),
+        TYPE_ALIAS => SymbolKind::TypeAlias,
-        TYPE_PARAM => HlTag::Symbol(SymbolKind::TypeParam),
+        TYPE_PARAM => SymbolKind::TypeParam,
-        RECORD_FIELD => HlTag::Symbol(SymbolKind::Field),
+        RECORD_FIELD => SymbolKind::Field,
-        MODULE => HlTag::Symbol(SymbolKind::Module),
+        MODULE => SymbolKind::Module,
-        FN => HlTag::Symbol(SymbolKind::Function),
+        FN => SymbolKind::Function,
-        CONST => HlTag::Symbol(SymbolKind::Const),
+        CONST => SymbolKind::Const,
-        STATIC => HlTag::Symbol(SymbolKind::Static),
+        STATIC => SymbolKind::Static,
-        IDENT_PAT => HlTag::Symbol(SymbolKind::Local),
+        IDENT_PAT => SymbolKind::Local,
-        _ => default,
+        _ => return default.into(),
    };
    tag.into()
@@ -492,20 +466,15 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
        METHOD_CALL_EXPR => {
            return ast::MethodCallExpr::cast(parent)
                .and_then(|it| highlight_method_call(sema, &it))
-                .unwrap_or_else(|| HlTag::Symbol(SymbolKind::Function).into());
+                .unwrap_or_else(|| SymbolKind::Function.into());
        }
        FIELD_EXPR => {
            let h = HlTag::Symbol(SymbolKind::Field);
            let is_union = ast::FieldExpr::cast(parent)
-                .and_then(|field_expr| {
+                .and_then(|field_expr| sema.resolve_field(&field_expr))
-                    let field = sema.resolve_field(&field_expr)?;
+                .map_or(false, |field| {
-                    Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
+                    matches!(field.parent_def(sema.db), hir::VariantDef::Union(_))
-                        true
+                });
-                    } else {
-                        false
-                    })
-                })
-                .unwrap_or(false);
            if is_union {
                h | HlMod::Unsafe
            } else {
@@ -522,9 +491,9 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
                _ => {
                    // within path, decide whether it is module or adt by checking for uppercase name
                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                        HlTag::Symbol(SymbolKind::Struct)
+                        SymbolKind::Struct
                    } else {
-                        HlTag::Symbol(SymbolKind::Module)
+                        SymbolKind::Module
                    }
                    .into();
                }
@@ -535,11 +504,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
            };
            match parent.kind() {
-                CALL_EXPR => HlTag::Symbol(SymbolKind::Function).into(),
+                CALL_EXPR => SymbolKind::Function.into(),
                _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                    HlTag::Symbol(SymbolKind::Struct)
+                    SymbolKind::Struct
                } else {
-                    HlTag::Symbol(SymbolKind::Const)
+                    SymbolKind::Const
                }
                .into(),
            }
@@ -574,6 +543,11 @@ fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[Sy
    kinds.len() == 0
 }
+#[inline]
+fn parent_matches<N: AstNode>(element: &SyntaxElement) -> bool {
+    element.parent().map_or(false, |it| N::can_cast(it.kind()))
+}
 fn is_child_of_impl(element: &SyntaxElement) -> bool {
    match element.parent() {
        Some(e) => e.kind() == IMPL,
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index e58392d67..a304b3250 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -40,28 +40,33 @@ pub enum HlTag {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum HlMod {
+    /// Used for items in traits and impls.
+    Associated = 0,
    /// Used to differentiate individual elements within attributes.
-    Attribute = 0,
+    Attribute,
+    /// Callable item or value.
+    Callable,
+    /// Value that is being consumed in a function call
+    Consuming,
    /// Used with keywords like `if` and `break`.
    ControlFlow,
    /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
    /// not.
    Definition,
+    /// Doc-strings like this one.
    Documentation,
+    /// Highlighting injection like rust code in doc strings or ra_fixture.
    Injected,
-    Mutable,
-    Consuming,
-    Callable,
-    /// Used for associated functions
-    Static,
-    /// Used for items in impls&traits.
-    Associated,
    /// Used for intra doc links in doc injection.
    IntraDocLink,
+    /// Mutable binding.
+    Mutable,
+    /// Used for associated functions.
+    Static,
    /// Used for items in traits and trait impls.
    Trait,
+    // Keep this last!
-    /// Keep this last!
+    /// Used for unsafe functions, mutable statics, union accesses and unsafe operations.
    Unsafe,
 }
@@ -169,17 +174,17 @@ impl fmt::Display for HlTag {
 impl HlMod {
    const ALL: &'static [HlMod; HlMod::Unsafe as u8 as usize + 1] = &[
+        HlMod::Associated,
        HlMod::Attribute,
+        HlMod::Callable,
+        HlMod::Consuming,
        HlMod::ControlFlow,
        HlMod::Definition,
        HlMod::Documentation,
-        HlMod::IntraDocLink,
        HlMod::Injected,
+        HlMod::IntraDocLink,
        HlMod::Mutable,
-        HlMod::Consuming,
-        HlMod::Callable,
        HlMod::Static,
-        HlMod::Associated,
        HlMod::Trait,
        HlMod::Unsafe,
    ];
@@ -229,6 +234,24 @@ impl From<HlTag> for Highlight {
    }
 }
+impl From<HlOperator> for Highlight {
+    fn from(op: HlOperator) -> Highlight {
+        Highlight::new(HlTag::Operator(op))
+    }
+}
+impl From<HlPunct> for Highlight {
+    fn from(punct: HlPunct) -> Highlight {
+        Highlight::new(HlTag::Punctuation(punct))
+    }
+}
+impl From<SymbolKind> for Highlight {
+    fn from(sym: SymbolKind) -> Highlight {
+        Highlight::new(HlTag::Symbol(sym))
+    }
+}
 impl Highlight {
    pub(crate) fn new(tag: HlTag) -> Highlight {
        Highlight { tag, mods: HlMods::default() }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index 8cde3906c..a0ea1db34 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -42,17 +42,17 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">foo</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">foo</span> <span class="brace">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration static">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration static associated trait">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration static trait">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">t_is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">t_is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="brace">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated trait">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration static trait">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated trait">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration trait">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
        </code></pre>
 \ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 6ee6d85fb..638f42c2f 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -50,7 +50,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment">//    KILLER WHALE</span>
    <span class="comment documentation">/// </span><span class="string_literal injected">    Ishmael."</span><span class="semicolon injected">;</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration associated">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="semicolon">;</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant associated declaration">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="semicolon">;</span>
    <span class="comment documentation">/// Constructs a new `Foo`.</span>
    <span class="comment documentation">///</span>
@@ -60,7 +60,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// #</span><span class="none injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="parenthesis attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="parenthesis attribute injected">)</span><span class="attribute attribute injected">]</span>
    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="keyword injected">mut</span><span class="none injected"> </span><span class="variable declaration injected mutable">foo</span><span class="colon injected">:</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static associated">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function associated declaration static">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="brace">{</span>
        <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">bar</span><span class="colon">:</span> <span class="bool_literal">true</span> <span class="brace">}</span>
    <span class="brace">}</span>
@@ -94,15 +94,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// ```sh</span>
    <span class="comment documentation">/// echo 1</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">foo</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration">foo</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="brace">{</span>
        <span class="bool_literal">true</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
-<span class="comment documentation">/// </span><span class="struct documentation intra_doc_link injected">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
+<span class="comment documentation">/// </span><span class="struct documentation injected intra_doc_link">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
-<span class="comment documentation">/// This function is &gt; </span><span class="function documentation intra_doc_link injected">[`all_the_links`](all_the_links)</span><span class="comment documentation"> &lt;</span>
+<span class="comment documentation">/// This function is &gt; </span><span class="function documentation injected intra_doc_link">[`all_the_links`](all_the_links)</span><span class="comment documentation"> &lt;</span>
 <span class="comment documentation">/// [`noop`](noop) is a macro below</span>
-<span class="comment documentation">/// </span><span class="struct documentation intra_doc_link injected">[`Item`]</span><span class="comment documentation"> is a struct in the module </span><span class="module documentation intra_doc_link injected">[`module`]</span>
+<span class="comment documentation">/// </span><span class="struct documentation injected intra_doc_link">[`Item`]</span><span class="comment documentation"> is a struct in the module </span><span class="module documentation injected intra_doc_link">[`module`]</span>
 <span class="comment documentation">///</span>
 <span class="comment documentation">/// [`Item`]: module::Item</span>
 <span class="comment documentation">/// [mix_and_match]: ThisShouldntResolve</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 7c6694a27..6202a03ce 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -42,7 +42,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
    <span class="function">fixture</span><span class="parenthesis">(</span><span class="string_literal">r#"</span>
        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="brace">{</span>
-            <span class="keyword">fn</span> <span class="function declaration static associated trait">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+            <span class="keyword">fn</span> <span class="function associated declaration static trait">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
                <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"2 + 2 = {}"</span><span class="comma">,</span> <span class="numeric_literal">4</span><span class="parenthesis">)</span><span class="semicolon">;</span>
            <span class="brace">}</span>
        <span class="brace">}</span><span class="string_literal">"#</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 72910421d..68165bdbf 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -47,7 +47,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="semicolon">;</span>
 <span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="brace">{</span>
-    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration associated unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function associated declaration unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">struct</span> <span class="struct declaration">TypeForStaticMut</span> <span class="brace">{</span>
@@ -62,11 +62,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index c43bcb691..4319e8b50 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -67,25 +67,25 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="semicolon">;</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration trait">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">Foo</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">baz</span><span class="parenthesis">(</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">Foo</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
-        <span class="value_param">f</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="self_keyword mutable consuming">self</span><span class="parenthesis">)</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function associated consuming">baz</span><span class="parenthesis">(</span><span class="self_keyword consuming mutable">self</span><span class="parenthesis">)</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
@@ -96,15 +96,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">FooCopy</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">baz</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">FooCopy</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
        <span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="parenthesis">)</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword declaration mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
    <span class="brace">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
        <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
    <span class="brace">}</span>
 <span class="brace">}</span>
@@ -128,7 +128,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword">use</span> <span class="module">ops</span><span class="operator">::</span><span class="trait">Fn</span><span class="semicolon">;</span>
-<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param declaration callable">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
+<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param callable declaration">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
    <span class="value_param callable">f</span><span class="parenthesis">(</span><span class="parenthesis">)</span>
 <span class="brace">}</span>
@@ -199,16 +199,16 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated mutable">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="variable consuming">foo2</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated consuming">baz</span><span class="parenthesis">(</span><span class="variable consuming">foo2</span><span class="parenthesis">)</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">copy</span> <span class="operator">=</span> <span class="struct">FooCopy</span> <span class="brace">{</span> <span class="field">x</span> <span class="brace">}</span><span class="semicolon">;</span>
    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated mutable">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="variable mutable">copy</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration callable">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration callable">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
@@ -228,7 +228,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">use</span> <span class="enum">Option</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 <span class="keyword">impl</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="angle">&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">T</span><span class="angle">&gt;</span> <span class="brace">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">and</span><span class="angle">&lt;</span><span class="type_param declaration">U</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">other</span><span class="colon">:</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">U</span><span class="angle">&gt;</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="comma">,</span> <span class="type_param">U</span><span class="parenthesis">)</span><span class="angle">&gt;</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function associated declaration">and</span><span class="angle">&lt;</span><span class="type_param declaration">U</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="self_keyword declaration">self</span><span class="comma">,</span> <span class="value_param declaration">other</span><span class="colon">:</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">U</span><span class="angle">&gt;</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="comma">,</span> <span class="type_param">U</span><span class="parenthesis">)</span><span class="angle">&gt;</span> <span class="brace">{</span>
        <span class="keyword control">match</span> <span class="value_param">other</span> <span class="brace">{</span>
            <span class="enum_variant">None</span> <span class="operator">=&gt;</span> <span class="macro">unimplemented!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="comma">,</span>
            <span class="variable declaration">Nope</span> <span class="operator">=&gt;</span> <span class="variable">Nope</span><span class="comma">,</span>
diff --git a/crates/ide_assists/src/ast_transform.rs b/crates/ide_assists/src/ast_transform.rs
index 4a3ed7783..e5ae718c9 100644
--- a/crates/ide_assists/src/ast_transform.rs
+++ b/crates/ide_assists/src/ast_transform.rs
@@ -3,20 +3,27 @@ use hir::{HirDisplay, PathResolution, SemanticsScope};
 use ide_db::helpers::mod_path_to_ast;
 use rustc_hash::FxHashMap;
 use syntax::{
-    algo::SyntaxRewriter,
    ast::{self, AstNode},
-    SyntaxNode,
+    ted, SyntaxNode,
 };
-pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
+pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: &N) {
-    SyntaxRewriter::from_fn(|element| match element {
+    let mut skip_to = None;
-        syntax::SyntaxElement::Node(n) => {
+    for event in node.syntax().preorder() {
-            let replacement = transformer.get_substitution(&n, transformer)?;
+        match event {
-            Some(replacement.into())
+            syntax::WalkEvent::Enter(node) if skip_to.is_none() => {
+                skip_to = transformer.get_substitution(&node, transformer).zip(Some(node));
+            }
+            syntax::WalkEvent::Enter(_) => (),
+            syntax::WalkEvent::Leave(node) => match &skip_to {
+                Some((replacement, skip_target)) if *skip_target == node => {
+                    ted::replace(node, replacement.clone_for_update());
+                    skip_to.take();
+                }
+                _ => (),
+            },
        }
-        _ => None,
+    }
-    })
-    .rewrite_ast(&node)
 }
 /// `AstTransform` helps with applying bulk transformations to syntax nodes.
@@ -191,11 +198,9 @@ impl<'a> AstTransform<'a> for QualifyPaths<'a> {
                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
                let mut path = mod_path_to_ast(&found_path);
-                let type_args = p
+                let type_args = p.segment().and_then(|s| s.generic_arg_list());
-                    .segment()
-                    .and_then(|s| s.generic_arg_list())
-                    .map(|arg_list| apply(recur, arg_list));
                if let Some(type_args) = type_args {
+                    apply(recur, &type_args);
                    let last_segment = path.segment().unwrap();
                    path = path.with_segment(last_segment.with_generic_args(type_args))
                }
diff --git a/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
new file mode 100644
index 000000000..b5b5ada5e
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -0,0 +1,516 @@
+use ide_db::defs::{Definition, NameRefClass};
+use syntax::{
+    ast::{self, AstNode, GenericParamsOwner, VisibilityOwner},
+    match_ast, SyntaxNode,
+};
+use crate::{assist_context::AssistBuilder, AssistContext, AssistId, AssistKind, Assists};
+// Assist: convert_tuple_struct_to_named_struct
+//
+// Converts tuple struct to struct with named fields.
+//
+// ```
+// struct Point$0(f32, f32);
+//
+// impl Point {
+//     pub fn new(x: f32, y: f32) -> Self {
+//         Point(x, y)
+//     }
+//
+//     pub fn x(&self) -> f32 {
+//         self.0
+//     }
+//
+//     pub fn y(&self) -> f32 {
+//         self.1
+//     }
+// }
+// ```
+// ->
+// ```
+// struct Point { field1: f32, field2: f32 }
+//
+// impl Point {
+//     pub fn new(x: f32, y: f32) -> Self {
+//         Point { field1: x, field2: y }
+//     }
+//
+//     pub fn x(&self) -> f32 {
+//         self.field1
+//     }
+//
+//     pub fn y(&self) -> f32 {
+//         self.field2
+//     }
+// }
+// ```
+pub(crate) fn convert_tuple_struct_to_named_struct(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let tuple_fields = match strukt.field_list()? {
+        ast::FieldList::TupleFieldList(it) => it,
+        ast::FieldList::RecordFieldList(_) => return None,
+    };
+    let strukt_def = ctx.sema.to_def(&strukt)?;
+    let target = strukt.syntax().text_range();
+    acc.add(
+        AssistId("convert_tuple_struct_to_named_struct", AssistKind::RefactorRewrite),
+        "Convert to named struct",
+        target,
+        |edit| {
+            let names = generate_names(tuple_fields.fields());
+            edit_field_references(ctx, edit, tuple_fields.fields(), &names);
+            edit_struct_references(ctx, edit, strukt_def, &names);
+            edit_struct_def(ctx, edit, &strukt, tuple_fields, names);
+        },
+    )
+}
+fn edit_struct_def(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    strukt: &ast::Struct,
+    tuple_fields: ast::TupleFieldList,
+    names: Vec<ast::Name>,
+) {
+    let record_fields = tuple_fields
+        .fields()
+        .zip(names)
+        .filter_map(|(f, name)| Some(ast::make::record_field(f.visibility(), name, f.ty()?)));
+    let record_fields = ast::make::record_field_list(record_fields);
+    let tuple_fields_text_range = tuple_fields.syntax().text_range();
+    edit.edit_file(ctx.frange.file_id);
+    if let Some(w) = strukt.where_clause() {
+        edit.delete(w.syntax().text_range());
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_newline().text());
+        edit.insert(tuple_fields_text_range.start(), w.syntax().text());
+        edit.insert(tuple_fields_text_range.start(), ",");
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_newline().text());
+    } else {
+        edit.insert(tuple_fields_text_range.start(), ast::make::tokens::single_space().text());
+    }
+    edit.replace(tuple_fields_text_range, record_fields.to_string());
+    strukt.semicolon_token().map(|t| edit.delete(t.text_range()));
+}
+fn edit_struct_references(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    strukt: hir::Struct,
+    names: &[ast::Name],
+) {
+    let strukt_def = Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Struct(strukt)));
+    let usages = strukt_def.usages(&ctx.sema).include_self_kw_refs(true).all();
+    let edit_node = |edit: &mut AssistBuilder, node: SyntaxNode| -> Option<()> {
+        match_ast! {
+            match node {
+                ast::TupleStructPat(tuple_struct_pat) => {
+                    edit.replace(
+                        tuple_struct_pat.syntax().text_range(),
+                        ast::make::record_pat_with_fields(
+                            tuple_struct_pat.path()?,
+                            ast::make::record_pat_field_list(tuple_struct_pat.fields().zip(names).map(
+                                |(pat, name)| {
+                                    ast::make::record_pat_field(
+                                        ast::make::name_ref(&name.to_string()),
+                                        pat,
+                                    )
+                                },
+                            )),
+                        )
+                        .to_string(),
+                    );
+                },
+                // for tuple struct creations like Foo(42)
+                ast::CallExpr(call_expr) => {
+                    let path = call_expr.syntax().descendants().find_map(ast::PathExpr::cast).and_then(|expr| expr.path())?;
+                    // this also includes method calls like Foo::new(42), we should skip them
+                    if let Some(name_ref) = path.segment().and_then(|s| s.name_ref()) {
+                        match NameRefClass::classify(&ctx.sema, &name_ref) {
+                            Some(NameRefClass::Definition(Definition::SelfType(_))) => {},
+                            Some(NameRefClass::Definition(def)) if def == strukt_def => {},
+                            _ => return None,
+                        };
+                    }
+                    let arg_list = call_expr.syntax().descendants().find_map(ast::ArgList::cast)?;
+                    edit.replace(
+                        call_expr.syntax().text_range(),
+                        ast::make::record_expr(
+                            path,
+                            ast::make::record_expr_field_list(arg_list.args().zip(names).map(
+                                |(expr, name)| {
+                                    ast::make::record_expr_field(
+                                        ast::make::name_ref(&name.to_string()),
+                                        Some(expr),
+                                    )
+                                },
+                            )),
+                        )
+                        .to_string(),
+                    );
+                },
+                _ => return None,
+            }
+        }
+        Some(())
+    };
+    for (file_id, refs) in usages {
+        edit.edit_file(file_id);
+        for r in refs {
+            for node in r.name.syntax().ancestors() {
+                if edit_node(edit, node).is_some() {
+                    break;
+                }
+            }
+        }
+    }
+}
+fn edit_field_references(
+    ctx: &AssistContext,
+    edit: &mut AssistBuilder,
+    fields: impl Iterator<Item = ast::TupleField>,
+    names: &[ast::Name],
+) {
+    for (field, name) in fields.zip(names) {
+        let field = match ctx.sema.to_def(&field) {
+            Some(it) => it,
+            None => continue,
+        };
+        let def = Definition::Field(field);
+        let usages = def.usages(&ctx.sema).all();
+        for (file_id, refs) in usages {
+            edit.edit_file(file_id);
+            for r in refs {
+                if let Some(name_ref) = r.name.as_name_ref() {
+                    edit.replace(name_ref.syntax().text_range(), name.text());
+                }
+            }
+        }
+    }
+}
+fn generate_names(fields: impl Iterator<Item = ast::TupleField>) -> Vec<ast::Name> {
+    fields.enumerate().map(|(i, _)| ast::make::name(&format!("field{}", i + 1))).collect()
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn not_applicable_other_than_tuple_struct() {
+        check_assist_not_applicable(
+            convert_tuple_struct_to_named_struct,
+            r#"struct Foo$0 { bar: u32 };"#,
+        );
+        check_assist_not_applicable(convert_tuple_struct_to_named_struct, r#"struct Foo$0;"#);
+    }
+    #[test]
+    fn convert_simple_struct() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn new(inner: Inner) -> A {
+        A(inner)
+    }
+    fn new_with_default() -> A {
+        A::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.0
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn new(inner: Inner) -> A {
+        A { field1: inner }
+    }
+    fn new_with_default() -> A {
+        A::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.field1
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_referenced_via_self_kw() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn new(inner: Inner) -> Self {
+        Self(inner)
+    }
+    fn new_with_default() -> Self {
+        Self::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.0
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn new(inner: Inner) -> Self {
+        Self { field1: inner }
+    }
+    fn new_with_default() -> Self {
+        Self::new(Inner)
+    }
+    fn into_inner(self) -> Inner {
+        self.field1
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_destructured_struct() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner;
+struct A$0(Inner);
+impl A {
+    fn into_inner(self) -> Inner {
+        let A(first) = self;
+        first
+    }
+    fn into_inner_via_self(self) -> Inner {
+        let Self(first) = self;
+        first
+    }
+}"#,
+            r#"
+struct Inner;
+struct A { field1: Inner }
+impl A {
+    fn into_inner(self) -> Inner {
+        let A { field1: first } = self;
+        first
+    }
+    fn into_inner_via_self(self) -> Inner {
+        let Self { field1: first } = self;
+        first
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_visibility() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct A$0(pub u32, pub(crate) u64);
+impl A {
+    fn new() -> A {
+        A(42, 42)
+    }
+    fn into_first(self) -> u32 {
+        self.0
+    }
+    fn into_second(self) -> u64 {
+        self.1
+    }
+}"#,
+            r#"
+struct A { pub field1: u32, pub(crate) field2: u64 }
+impl A {
+    fn new() -> A {
+        A { field1: 42, field2: 42 }
+    }
+    fn into_first(self) -> u32 {
+        self.field1
+    }
+    fn into_second(self) -> u64 {
+        self.field2
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_wrapped_references() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner$0(u32);
+struct Outer(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner(42))
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner(x)) = self;
+        x
+    }
+}"#,
+            r#"
+struct Inner { field1: u32 }
+struct Outer(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner { field1: 42 })
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).field1
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner { field1: x }) = self;
+        x
+    }
+}"#,
+        );
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Inner(u32);
+struct Outer$0(Inner);
+impl Outer {
+    fn new() -> Self {
+        Self(Inner(42))
+    }
+    fn into_inner(self) -> u32 {
+        (self.0).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer(Inner(x)) = self;
+        x
+    }
+}"#,
+            r#"
+struct Inner(u32);
+struct Outer { field1: Inner }
+impl Outer {
+    fn new() -> Self {
+        Self { field1: Inner(42) }
+    }
+    fn into_inner(self) -> u32 {
+        (self.field1).0
+    }
+    fn into_inner_destructed(self) -> u32 {
+        let Outer { field1: Inner(x) } = self;
+        x
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_multi_file_references() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+//- /main.rs
+struct Inner;
+struct A$0(Inner);
+mod foo;
+//- /foo.rs
+use crate::{A, Inner};
+fn f() {
+    let a = A(Inner);
+}
+"#,
+            r#"
+//- /main.rs
+struct Inner;
+struct A { field1: Inner }
+mod foo;
+//- /foo.rs
+use crate::{A, Inner};
+fn f() {
+    let a = A { field1: Inner };
+}
+"#,
+        );
+    }
+    #[test]
+    fn convert_struct_with_where_clause() {
+        check_assist(
+            convert_tuple_struct_to_named_struct,
+            r#"
+struct Wrap$0<T>(T)
+where
+    T: Display;
+"#,
+            r#"
+struct Wrap<T>
+where
+    T: Display,
+{ field1: T }
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index 78a57fbdc..5f80a40c8 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -1227,9 +1227,19 @@ fn make_body(
        FunctionBody::Expr(expr) => {
            let expr = rewrite_body_segment(ctx, &fun.params, &handler, expr.syntax());
            let expr = ast::Expr::cast(expr).unwrap();
-            let expr = expr.dedent(old_indent).indent(IndentLevel(1));
+            match expr {
+                ast::Expr::BlockExpr(block) => {
+                    // If the extracted expression is itself a block, there is no need to wrap it inside another block.
+                    let block = block.dedent(old_indent);
+                    // Recreate the block for formatting consistency with other extracted functions.
+                    make::block_expr(block.statements(), block.tail_expr())
+                }
+                _ => {
+                    let expr = expr.dedent(old_indent).indent(IndentLevel(1));
-            make::block_expr(Vec::new(), Some(expr))
+                    make::block_expr(Vec::new(), Some(expr))
+                }
+            }
        }
        FunctionBody::Span { parent, text_range } => {
            let mut elements: Vec<_> = parent
@@ -1544,7 +1554,7 @@ fn foo() {
 }
 fn $0fun_name() -> i32 {
-    { 1 + 1 }
+    1 + 1
 }"#,
        );
    }
@@ -2526,17 +2536,15 @@ fn foo() {
 }
 fn $0fun_name(n: &mut i32) {
-    {
+    *n += *n;
-        *n += *n;
+    bar(*n);
-        bar(*n);
+    bar(*n+1);
-        bar(*n+1);
+    bar(*n**n);
-        bar(*n**n);
+    bar(&*n);
-        bar(&*n);
+    n.inc();
-        n.inc();
+    let v = n;
-        let v = n;
+    *v = v.succ();
-        *v = v.succ();
+    n.succ();
-        n.succ();
-    }
 }",
        );
    }
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index a30c4d04e..be927cc1c 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -53,7 +53,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        .iter()
        .filter_map(ast::MatchArm::pat)
        .flat_map(|pat| match pat {
-            // Special casee OrPat as separate top-level pats
+            // Special case OrPat as separate top-level pats
            Pat::OrPat(or_pat) => Either::Left(or_pat.pats()),
            _ => Either::Right(iter::once(pat)),
        })
@@ -72,7 +72,11 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
            .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
            .collect::<Vec<_>>();
-        if Some(enum_def) == FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option() {
+        if Some(enum_def)
+            == FamousDefs(&ctx.sema, Some(module.krate()))
+                .core_option_Option()
+                .map(|x| lift_enum(x))
+        {
            // Match `Some` variant first.
            cov_mark::hit!(option_order);
            variants.reverse()
@@ -151,49 +155,99 @@ fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
    }
 }
-fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
+#[derive(Eq, PartialEq, Clone)]
+enum ExtendedEnum {
+    Bool,
+    Enum(hir::Enum),
+}
+#[derive(Eq, PartialEq, Clone)]
+enum ExtendedVariant {
+    True,
+    False,
+    Variant(hir::Variant),
+}
+fn lift_enum(e: hir::Enum) -> ExtendedEnum {
+    ExtendedEnum::Enum(e)
+}
+impl ExtendedEnum {
+    fn variants(&self, db: &RootDatabase) -> Vec<ExtendedVariant> {
+        match self {
+            ExtendedEnum::Enum(e) => {
+                e.variants(db).into_iter().map(|x| ExtendedVariant::Variant(x)).collect::<Vec<_>>()
+            }
+            ExtendedEnum::Bool => {
+                Vec::<ExtendedVariant>::from([ExtendedVariant::True, ExtendedVariant::False])
+            }
+        }
+    }
+}
+fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<ExtendedEnum> {
    sema.type_of_expr(&expr)?.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
-        Some(Adt::Enum(e)) => Some(e),
+        Some(Adt::Enum(e)) => Some(ExtendedEnum::Enum(e)),
-        _ => None,
+        _ => {
+            if ty.is_bool() {
+                Some(ExtendedEnum::Bool)
+            } else {
+                None
+            }
+        }
    })
 }
 fn resolve_tuple_of_enum_def(
    sema: &Semantics<RootDatabase>,
    expr: &ast::Expr,
-) -> Option<Vec<hir::Enum>> {
+) -> Option<Vec<ExtendedEnum>> {
    sema.type_of_expr(&expr)?
        .tuple_fields(sema.db)
        .iter()
        .map(|ty| {
            ty.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
-                Some(Adt::Enum(e)) => Some(e),
+                Some(Adt::Enum(e)) => Some(lift_enum(e)),
                // For now we only handle expansion for a tuple of enums. Here
                // we map non-enum items to None and rely on `collect` to
                // convert Vec<Option<hir::Enum>> into Option<Vec<hir::Enum>>.
-                _ => None,
+                _ => {
+                    if ty.is_bool() {
+                        Some(ExtendedEnum::Bool)
+                    } else {
+                        None
+                    }
+                }
            })
        })
        .collect()
 }
-fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::Variant) -> Option<ast::Pat> {
+fn build_pat(db: &RootDatabase, module: hir::Module, var: ExtendedVariant) -> Option<ast::Pat> {
-    let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
+    match var {
+        ExtendedVariant::Variant(var) => {
+            let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
+            // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
+            let pat: ast::Pat = match var.source(db)?.value.kind() {
+                ast::StructKind::Tuple(field_list) => {
+                    let pats =
+                        iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
+                    make::tuple_struct_pat(path, pats).into()
+                }
+                ast::StructKind::Record(field_list) => {
+                    let pats =
+                        field_list.fields().map(|f| make::ident_pat(f.name().unwrap()).into());
+                    make::record_pat(path, pats).into()
+                }
+                ast::StructKind::Unit => make::path_pat(path),
+            };
-    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
+            Some(pat)
-    let pat: ast::Pat = match var.source(db)?.value.kind() {
-        ast::StructKind::Tuple(field_list) => {
-            let pats = iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
-            make::tuple_struct_pat(path, pats).into()
-        }
-        ast::StructKind::Record(field_list) => {
-            let pats = field_list.fields().map(|f| make::ident_pat(f.name().unwrap()).into());
-            make::record_pat(path, pats).into()
        }
-        ast::StructKind::Unit => make::path_pat(path),
+        ExtendedVariant::True => Some(ast::Pat::from(make::literal_pat("true"))),
-    };
+        ExtendedVariant::False => Some(ast::Pat::from(make::literal_pat("false"))),
+    }
-    Some(pat)
 }
 #[cfg(test)]
@@ -226,6 +280,21 @@ mod tests {
    }
    #[test]
+    fn all_boolean_match_arms_provided() {
+        check_assist_not_applicable(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                    true => {}
+                    false => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
    fn tuple_of_non_enum() {
        // for now this case is not handled, although it potentially could be
        // in the future
@@ -241,6 +310,113 @@ mod tests {
    }
    #[test]
+    fn fill_match_arms_boolean() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match a {
+                    $0true => {}
+                    false => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn partial_fill_boolean() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                    true => {}
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match a {
+                    true => {}
+                    $0false => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn all_boolean_tuple_arms_provided() {
+        check_assist_not_applicable(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                    (true, true) => {}
+                    (true, false) => {}
+                    (false, true) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn fill_boolean_tuple() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match (a, a) {
+                    $0(true, true) => {}
+                    (true, false) => {}
+                    (false, true) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn partial_fill_boolean_tuple() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                    (false, true) => {}
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match (a, a) {
+                    (false, true) => {}
+                    $0(true, true) => {}
+                    (true, false) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+    #[test]
    fn partial_fill_record_tuple() {
        check_assist(
            fill_match_arms,
diff --git a/crates/ide_assists/src/handlers/inline_local_variable.rs b/crates/ide_assists/src/handlers/inline_local_variable.rs
index ea1466dc8..f5dafc8cb 100644
--- a/crates/ide_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ide_assists/src/handlers/inline_local_variable.rs
@@ -1,7 +1,9 @@
-use ide_db::{defs::Definition, search::FileReference};
+use either::Either;
+use hir::PathResolution;
+use ide_db::{base_db::FileId, defs::Definition, search::FileReference};
 use rustc_hash::FxHashMap;
 use syntax::{
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode, AstToken, NameOwner},
    TextRange,
 };
@@ -27,44 +29,28 @@ use crate::{
 // }
 // ```
 pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
+    let InlineData { let_stmt, delete_let, replace_usages, target } =
-    let bind_pat = match let_stmt.pat()? {
+        inline_let(ctx).or_else(|| inline_usage(ctx))?;
-        ast::Pat::IdentPat(pat) => pat,
-        _ => return None,
-    };
-    if bind_pat.mut_token().is_some() {
-        cov_mark::hit!(test_not_inline_mut_variable);
-        return None;
-    }
-    if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
-        cov_mark::hit!(not_applicable_outside_of_bind_pat);
-        return None;
-    }
    let initializer_expr = let_stmt.initializer()?;
-    let def = ctx.sema.to_def(&bind_pat)?;
+    let delete_range = if delete_let {
-    let def = Definition::Local(def);
+        if let Some(whitespace) = let_stmt
-    let usages = def.usages(&ctx.sema).all();
+            .syntax()
-    if usages.is_empty() {
+            .next_sibling_or_token()
-        cov_mark::hit!(test_not_applicable_if_variable_unused);
+            .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
-        return None;
+        {
-    };
+            Some(TextRange::new(
+                let_stmt.syntax().text_range().start(),
-    let delete_range = if let Some(whitespace) = let_stmt
+                whitespace.syntax().text_range().end(),
-        .syntax()
+            ))
-        .next_sibling_or_token()
+        } else {
-        .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
+            Some(let_stmt.syntax().text_range())
-    {
+        }
-        TextRange::new(
-            let_stmt.syntax().text_range().start(),
-            whitespace.syntax().text_range().end(),
-        )
    } else {
-        let_stmt.syntax().text_range()
+        None
    };
-    let wrap_in_parens = usages
+    let wrap_in_parens = replace_usages
-        .references
        .iter()
        .map(|(&file_id, refs)| {
            refs.iter()
@@ -114,14 +100,20 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
    let init_str = initializer_expr.syntax().text().to_string();
    let init_in_paren = format!("({})", &init_str);
-    let target = bind_pat.syntax().text_range();
+    let target = match target {
+        ast::NameOrNameRef::Name(it) => it.syntax().text_range(),
+        ast::NameOrNameRef::NameRef(it) => it.syntax().text_range(),
+    };
    acc.add(
        AssistId("inline_local_variable", AssistKind::RefactorInline),
        "Inline variable",
        target,
        move |builder| {
-            builder.delete(delete_range);
+            if let Some(range) = delete_range {
-            for (file_id, references) in usages.references {
+                builder.delete(range);
+            }
+            for (file_id, references) in replace_usages {
                for (&should_wrap, reference) in wrap_in_parens[&file_id].iter().zip(references) {
                    let replacement =
                        if should_wrap { init_in_paren.clone() } else { init_str.clone() };
@@ -140,6 +132,81 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
    )
 }
+struct InlineData {
+    let_stmt: ast::LetStmt,
+    delete_let: bool,
+    target: ast::NameOrNameRef,
+    replace_usages: FxHashMap<FileId, Vec<FileReference>>,
+}
+fn inline_let(ctx: &AssistContext) -> Option<InlineData> {
+    let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
+    let bind_pat = match let_stmt.pat()? {
+        ast::Pat::IdentPat(pat) => pat,
+        _ => return None,
+    };
+    if bind_pat.mut_token().is_some() {
+        cov_mark::hit!(test_not_inline_mut_variable);
+        return None;
+    }
+    if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
+        cov_mark::hit!(not_applicable_outside_of_bind_pat);
+        return None;
+    }
+    let def = ctx.sema.to_def(&bind_pat)?;
+    let def = Definition::Local(def);
+    let usages = def.usages(&ctx.sema).all();
+    if usages.is_empty() {
+        cov_mark::hit!(test_not_applicable_if_variable_unused);
+        return None;
+    };
+    Some(InlineData {
+        let_stmt,
+        delete_let: true,
+        target: ast::NameOrNameRef::Name(bind_pat.name()?),
+        replace_usages: usages.references,
+    })
+}
+fn inline_usage(ctx: &AssistContext) -> Option<InlineData> {
+    let path_expr = ctx.find_node_at_offset::<ast::PathExpr>()?;
+    let path = path_expr.path()?;
+    let name = match path.as_single_segment()?.kind()? {
+        ast::PathSegmentKind::Name(name) => name,
+        _ => return None,
+    };
+    let local = match ctx.sema.resolve_path(&path)? {
+        PathResolution::Local(local) => local,
+        _ => return None,
+    };
+    let bind_pat = match local.source(ctx.db()).value {
+        Either::Left(ident) => ident,
+        _ => return None,
+    };
+    let let_stmt = ast::LetStmt::cast(bind_pat.syntax().parent()?)?;
+    let def = Definition::Local(local);
+    let mut usages = def.usages(&ctx.sema).all();
+    let delete_let = usages.references.values().map(|v| v.len()).sum::<usize>() == 1;
+    for references in usages.references.values_mut() {
+        references.retain(|reference| reference.name.as_name_ref() == Some(&name));
+    }
+    Some(InlineData {
+        let_stmt,
+        delete_let,
+        target: ast::NameOrNameRef::NameRef(name),
+        replace_usages: usages.references,
+    })
+}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -726,4 +793,84 @@ fn main() {
 ",
        )
    }
+    #[test]
+    fn works_on_local_usage() {
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    let xyz = 0;
+    xyz$0;
+}
+"#,
+            r#"
+fn f() {
+    0;
+}
+"#,
+        );
+    }
+    #[test]
+    fn does_not_remove_let_when_multiple_usages() {
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    let xyz = 0;
+    xyz$0;
+    xyz;
+}
+"#,
+            r#"
+fn f() {
+    let xyz = 0;
+    0;
+    xyz;
+}
+"#,
+        );
+    }
+    #[test]
+    fn not_applicable_with_non_ident_pattern() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+fn main() {
+    let (x, y) = (0, 1);
+    x$0;
+}
+"#,
+        );
+    }
+    #[test]
+    fn not_applicable_on_local_usage_in_macro() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+macro_rules! m {
+    ($i:ident) => { $i }
+}
+fn f() {
+    let xyz = 0;
+    m!(xyz$0); // replacing it would break the macro
+}
+"#,
+        );
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+macro_rules! m {
+    ($i:ident) => { $i }
+}
+fn f() {
+    let xyz$0 = 0;
+    m!(xyz); // replacing it would break the macro
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
index 870a8d4ff..694d897d1 100644
--- a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -47,6 +47,11 @@ pub(crate) fn replace_derive_with_manual_impl(
        return None;
    }
+    if !args.syntax().text_range().contains(ctx.offset()) {
+        cov_mark::hit!(outside_of_attr_args);
+        return None;
+    }
    let trait_token = args.syntax().token_at_offset(ctx.offset()).find(|t| t.kind() == IDENT)?;
    let trait_name = trait_token.text();
@@ -207,7 +212,7 @@ mod tests {
    fn add_custom_impl_debug() {
        check_assist(
            replace_derive_with_manual_impl,
-            "
+            r#"
 mod fmt {
    pub struct Error;
    pub type Result = Result<(), Error>;
@@ -221,8 +226,8 @@ mod fmt {
 struct Foo {
    bar: String,
 }
-",
+"#,
-            "
+            r#"
 mod fmt {
    pub struct Error;
    pub type Result = Result<(), Error>;
@@ -241,14 +246,14 @@ impl fmt::Debug for Foo {
        ${0:todo!()}
    }
 }
-",
+"#,
        )
    }
    #[test]
    fn add_custom_impl_all() {
        check_assist(
            replace_derive_with_manual_impl,
-            "
+            r#"
 mod foo {
    pub trait Bar {
        type Qux;
@@ -263,8 +268,8 @@ mod foo {
 struct Foo {
    bar: String,
 }
-",
+"#,
-            "
+            r#"
 mod foo {
    pub trait Bar {
        type Qux;
@@ -290,20 +295,20 @@ impl foo::Bar for Foo {
        todo!()
    }
 }
-",
+"#,
        )
    }
    #[test]
    fn add_custom_impl_for_unique_input() {
        check_assist(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debu$0g)]
 struct Foo {
    bar: String,
 }
-            ",
+            "#,
-            "
+            r#"
 struct Foo {
    bar: String,
 }
@@ -311,7 +316,7 @@ struct Foo {
 impl Debug for Foo {
    $0
 }
-            ",
+            "#,
        )
    }
@@ -319,13 +324,13 @@ impl Debug for Foo {
    fn add_custom_impl_for_with_visibility_modifier() {
        check_assist(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debug$0)]
 pub struct Foo {
    bar: String,
 }
-            ",
+            "#,
-            "
+            r#"
 pub struct Foo {
    bar: String,
 }
@@ -333,7 +338,7 @@ pub struct Foo {
 impl Debug for Foo {
    $0
 }
-            ",
+            "#,
        )
    }
@@ -341,18 +346,18 @@ impl Debug for Foo {
    fn add_custom_impl_when_multiple_inputs() {
        check_assist(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Display, Debug$0, Serialize)]
 struct Foo {}
-            ",
+            "#,
-            "
+            r#"
 #[derive(Display, Serialize)]
 struct Foo {}
 impl Debug for Foo {
    $0
 }
-            ",
+            "#,
        )
    }
@@ -360,10 +365,10 @@ impl Debug for Foo {
    fn test_ignore_derive_macro_without_input() {
        check_assist_not_applicable(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive($0)]
 struct Foo {}
-            ",
+            "#,
        )
    }
@@ -371,18 +376,18 @@ struct Foo {}
    fn test_ignore_if_cursor_on_param() {
        check_assist_not_applicable(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive$0(Debug)]
 struct Foo {}
-            ",
+            "#,
        );
        check_assist_not_applicable(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debug)$0]
 struct Foo {}
-            ",
+            "#,
        )
    }
@@ -390,10 +395,22 @@ struct Foo {}
    fn test_ignore_if_not_derive() {
        check_assist_not_applicable(
            replace_derive_with_manual_impl,
-            "
+            r#"
 #[allow(non_camel_$0case_types)]
 struct Foo {}
-            ",
+            "#,
        )
    }
+    #[test]
+    fn works_at_start_of_file() {
+        cov_mark::check!(outside_of_attr_args);
+        check_assist_not_applicable(
+            replace_derive_with_manual_impl,
+            r#"
+$0#[derive(Debug)]
+struct S;
+            "#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 8996c1b61..88ae5c9a9 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -120,6 +120,7 @@ mod handlers {
    mod convert_comment_block;
    mod convert_iter_for_each_to_for;
    mod convert_into_to_from;
+    mod convert_tuple_struct_to_named_struct;
    mod early_return;
    mod expand_glob_import;
    mod extract_function;
@@ -190,6 +191,7 @@ mod handlers {
            convert_comment_block::convert_comment_block,
            convert_iter_for_each_to_for::convert_iter_for_each_to_for,
            convert_into_to_from::convert_into_to_from,
+            convert_tuple_struct_to_named_struct::convert_tuple_struct_to_named_struct,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 41559b43a..59bcef8fb 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -292,6 +292,47 @@ fn main() {
 }
 #[test]
+fn doctest_convert_tuple_struct_to_named_struct() {
+    check_doc_test(
+        "convert_tuple_struct_to_named_struct",
+        r#####"
+struct Point$0(f32, f32);
+impl Point {
+    pub fn new(x: f32, y: f32) -> Self {
+        Point(x, y)
+    }
+    pub fn x(&self) -> f32 {
+        self.0
+    }
+    pub fn y(&self) -> f32 {
+        self.1
+    }
+}
+"#####,
+        r#####"
+struct Point { field1: f32, field2: f32 }
+impl Point {
+    pub fn new(x: f32, y: f32) -> Self {
+        Point { field1: x, field2: y }
+    }
+    pub fn x(&self) -> f32 {
+        self.field1
+    }
+    pub fn y(&self) -> f32 {
+        self.field2
+    }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_expand_glob_import() {
    check_doc_test(
        "expand_glob_import",
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs
index d67524937..5a90ad715 100644
--- a/crates/ide_assists/src/utils.rs
+++ b/crates/ide_assists/src/utils.rs
@@ -140,7 +140,8 @@ pub fn add_trait_assoc_items_to_impl(
    let items = items
        .into_iter()
-        .map(|it| ast_transform::apply(&*ast_transform, it))
+        .map(|it| it.clone_for_update())
+        .inspect(|it| ast_transform::apply(&*ast_transform, it))
        .map(|it| match it {
            ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)),
            ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()),
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index b55e3851e..8f899ea56 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -7,7 +7,9 @@
 use std::{convert::TryInto, mem};
 use base_db::{FileId, FileRange, SourceDatabase, SourceDatabaseExt};
-use hir::{DefWithBody, HasAttrs, HasSource, InFile, ModuleSource, Semantics, Visibility};
+use hir::{
+    DefWithBody, HasAttrs, HasSource, InFile, ModuleDef, ModuleSource, Semantics, Visibility,
+};
 use once_cell::unsync::Lazy;
 use rustc_hash::FxHashMap;
 use syntax::{ast, match_ast, AstNode, TextRange, TextSize};
@@ -295,7 +297,7 @@ impl Definition {
    }
    pub fn usages<'a>(&'a self, sema: &'a Semantics<RootDatabase>) -> FindUsages<'a> {
-        FindUsages { def: self, sema, scope: None }
+        FindUsages { def: self, sema, scope: None, include_self_kw_refs: false }
    }
 }
@@ -303,9 +305,15 @@ pub struct FindUsages<'a> {
    def: &'a Definition,
    sema: &'a Semantics<'a, RootDatabase>,
    scope: Option<SearchScope>,
+    include_self_kw_refs: bool,
 }
 impl<'a> FindUsages<'a> {
+    pub fn include_self_kw_refs(mut self, include: bool) -> FindUsages<'a> {
+        self.include_self_kw_refs = include;
+        self
+    }
    pub fn in_scope(self, scope: SearchScope) -> FindUsages<'a> {
        self.set_scope(Some(scope))
    }
@@ -352,6 +360,8 @@ impl<'a> FindUsages<'a> {
        };
        let pat = name.as_str();
+        let search_for_self = self.include_self_kw_refs;
        for (file_id, search_range) in search_scope {
            let text = sema.db.file_text(file_id);
            let search_range =
@@ -359,31 +369,47 @@ impl<'a> FindUsages<'a> {
            let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
-            for (idx, _) in text.match_indices(pat) {
+            let mut handle_match = |idx: usize| -> bool {
                let offset: TextSize = idx.try_into().unwrap();
                if !search_range.contains_inclusive(offset) {
-                    continue;
+                    return false;
                }
                if let Some(name) = sema.find_node_at_offset_with_descend(&tree, offset) {
                    match name {
                        ast::NameLike::NameRef(name_ref) => {
                            if self.found_name_ref(&name_ref, sink) {
-                                return;
+                                return true;
                            }
                        }
                        ast::NameLike::Name(name) => {
                            if self.found_name(&name, sink) {
-                                return;
+                                return true;
                            }
                        }
                        ast::NameLike::Lifetime(lifetime) => {
                            if self.found_lifetime(&lifetime, sink) {
-                                return;
+                                return true;
                            }
                        }
                    }
                }
+                return false;
+            };
+            for (idx, _) in text.match_indices(pat) {
+                if handle_match(idx) {
+                    return;
+                }
+            }
+            if search_for_self {
+                for (idx, _) in text.match_indices("Self") {
+                    if handle_match(idx) {
+                        return;
+                    }
+                }
            }
        }
    }
@@ -422,6 +448,24 @@ impl<'a> FindUsages<'a> {
                };
                sink(file_id, reference)
            }
+            Some(NameRefClass::Definition(Definition::SelfType(impl_))) => {
+                let ty = impl_.self_ty(self.sema.db);
+                if let Some(adt) = ty.as_adt() {
+                    if &Definition::ModuleDef(ModuleDef::Adt(adt)) == self.def {
+                        let FileRange { file_id, range } =
+                            self.sema.original_range(name_ref.syntax());
+                        let reference = FileReference {
+                            range,
+                            name: ast::NameLike::NameRef(name_ref.clone()),
+                            access: None,
+                        };
+                        return sink(file_id, reference);
+                    }
+                }
+                false
+            }
            Some(NameRefClass::FieldShorthand { local_ref: local, field_ref: field }) => {
                let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
                let reference = match self.def {
diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
index da71498a8..3ab347834 100644
--- a/crates/parser/src/grammar/patterns.rs
+++ b/crates/parser/src/grammar/patterns.rs
@@ -206,13 +206,15 @@ fn record_pat_field_list(p: &mut Parser) {
            T![.] if p.at(T![..]) => p.bump(T![..]),
            T!['{'] => error_block(p, "expected ident"),
-            c => {
+            _ => {
                let m = p.start();
-                match c {
+                attributes::outer_attrs(p);
+                match p.current() {
                    // test record_pat_field
                    // fn foo() {
                    //     let S { 0: 1 } = ();
                    //     let S { x: 1 } = ();
+                    //     let S { #[cfg(any())] x: 1 } = ();
                    // }
                    IDENT | INT_NUMBER if p.nth(1) == T![:] => {
                        name_ref_or_index(p);
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index 16fd56c7e..1ba1e4abd 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -15,10 +15,11 @@ serde_json = { version = "1.0", features = ["unbounded_depth"] }
 log = "0.4.8"
 crossbeam-channel = "0.5.0"
 jod-thread = "0.1.1"
+memmap = "0.7.0"
+object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+snap = "1.0"
 tt = { path = "../tt", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
-snap = "1"
+profile = { path = "../profile", version = "0.0.0" }
-object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
-memmap = "0.7.0"
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 2dd2a8541..654bd9943 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -77,6 +77,7 @@ impl ProcMacroClient {
    }
    pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
+        let _p = profile::span("ProcMacroClient::by_dylib_path");
        match version::read_dylib_info(dylib_path) {
            Ok(info) => {
                if info.version.0 < 1 || info.version.1 < 47 {
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index ab5cc8c49..faca336de 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -1,7 +1,6 @@
 //! Handles build script specific information
 use std::{
-    io::BufReader,
    path::PathBuf,
    process::{Command, Stdio},
    sync::Arc,
@@ -13,7 +12,8 @@ use cargo_metadata::{BuildScript, Message};
 use itertools::Itertools;
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use stdx::{format_to, JodChild};
+use serde::Deserialize;
+use stdx::format_to;
 use crate::{cfg_flag::CfgFlag, CargoConfig};
@@ -171,67 +171,86 @@ impl WorkspaceBuildData {
        cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).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 = WorkspaceBuildData::default();
-        for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
-            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 package_build_data =
-                        res.per_package.entry(package_id.repr.clone()).or_default();
-                    // cargo_metadata crate returns default (empty) path for
-                    // older cargos, which is not absolute, so work around that.
-                    if !out_dir.as_str().is_empty() {
-                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
-                        package_build_data.out_dir = Some(out_dir);
-                        package_build_data.cfgs = cfgs;
-                    }
-                    package_build_data.envs = env;
+        let mut callback_err = None;
+        let output = stdx::process::streaming_output(
+            cmd,
+            &mut |line| {
+                if callback_err.is_some() {
+                    return;
                }
-                Message::CompilerArtifact(message) => {
-                    progress(format!("metadata {}", message.target.name));
+                // Copy-pasted from existing cargo_metadata. It seems like we
+                // should be using sered_stacker here?
-                    if message.target.kind.contains(&"proc-macro".to_string()) {
+                let mut deserializer = serde_json::Deserializer::from_str(&line);
-                        let package_id = message.package_id;
+                deserializer.disable_recursion_limit();
-                        // Skip rmeta file
+                let message = Message::deserialize(&mut deserializer)
-                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
+                    .unwrap_or(Message::TextLine(line.to_string()));
-                        {
-                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
+                match message {
-                            let package_build_data =
+                    Message::BuildScriptExecuted(BuildScript {
-                                res.per_package.entry(package_id.repr.clone()).or_default();
+                        package_id,
-                            package_build_data.proc_macro_dylib_path = Some(filename);
+                        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) => {
+                                        callback_err = Some(anyhow::format_err!(
+                                            "invalid cfg from cargo-metadata: {}",
+                                            err
+                                        ));
+                                        return;
+                                    }
+                                };
+                            }
+                            acc
+                        };
+                        let package_build_data =
+                            res.per_package.entry(package_id.repr.clone()).or_default();
+                        // cargo_metadata crate returns default (empty) path for
+                        // older cargos, which is not absolute, so work around that.
+                        if !out_dir.as_str().is_empty() {
+                            let out_dir =
+                                AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
+                            package_build_data.out_dir = Some(out_dir);
+                            package_build_data.cfgs = cfgs;
                        }
+                        package_build_data.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(PathBuf::from(&filename));
+                                let package_build_data =
+                                    res.per_package.entry(package_id.repr.clone()).or_default();
+                                package_build_data.proc_macro_dylib_path = Some(filename);
+                            }
+                        }
+                    }
+                    Message::CompilerMessage(message) => {
+                        progress(message.target.name.clone());
+                    }
+                    Message::BuildFinished(_) => {}
+                    Message::TextLine(_) => {}
+                    _ => {}
                }
-                Message::CompilerMessage(message) => {
+            },
-                    progress(message.target.name.clone());
+            &mut |_| (),
-                }
+        )?;
-                Message::BuildFinished(_) => {}
-                Message::TextLine(_) => {}
-                _ => {}
-            }
-        }
        for package in packages {
            let package_build_data = res.per_package.entry(package.id.repr.clone()).or_default();
@@ -244,7 +263,6 @@ impl WorkspaceBuildData {
            }
        }
-        let output = child.into_inner().wait_with_output()?;
        if !output.status.success() {
            let mut stderr = String::from_utf8(output.stderr).unwrap_or_default();
            if stderr.is_empty() {
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 7ddea22c8..1109d2daf 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -17,7 +17,7 @@ use ide_db::helpers::{
 };
 use lsp_types::{ClientCapabilities, MarkupKind};
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest, RustcSource};
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use serde::{de::DeserializeOwned, Deserialize};
 use vfs::AbsPathBuf;
@@ -99,6 +99,9 @@ config_data! {
        diagnostics_enableExperimental: bool    = "true",
        /// List of rust-analyzer diagnostics to disable.
        diagnostics_disabled: FxHashSet<String> = "[]",
+        /// Map of prefixes to be substituted when parsing diagnostic file paths.
+        /// This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.
+        diagnostics_remapPrefix: FxHashMap<String, String> = "{}",
        /// List of warnings that should be displayed with info severity.
        ///
        /// The warnings will be indicated by a blue squiggly underline in code
@@ -474,6 +477,7 @@ impl Config {
    }
    pub fn diagnostics_map(&self) -> DiagnosticsMapConfig {
        DiagnosticsMapConfig {
+            remap_prefix: self.data.diagnostics_remapPrefix.clone(),
            warnings_as_info: self.data.diagnostics_warningsAsInfo.clone(),
            warnings_as_hint: self.data.diagnostics_warningsAsHint.clone(),
        }
@@ -835,6 +839,9 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
            "items": { "type": "string" },
            "uniqueItems": true,
        },
+        "FxHashMap<String, String>" => set! {
+            "type": "object",
+        },
        "Option<usize>" => set! {
            "type": ["null", "integer"],
            "minimum": 0,
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index f01548c50..d4b9db362 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -12,6 +12,7 @@ pub(crate) type CheckFixes = Arc<FxHashMap<FileId, Vec<Fix>>>;
 #[derive(Debug, Default, Clone)]
 pub struct DiagnosticsMapConfig {
+    pub remap_prefix: FxHashMap<String, String>,
    pub warnings_as_info: Vec<String>,
    pub warnings_as_hint: Vec<String>,
 }
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index ca18997e4..82dd0da9a 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -1,6 +1,9 @@
 //! This module provides the functionality needed to convert diagnostics from
 //! `cargo check` json format to the LSP diagnostic format.
-use std::{collections::HashMap, path::Path};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
 use flycheck::{DiagnosticLevel, DiagnosticSpan};
 use stdx::format_to;
@@ -41,8 +44,12 @@ fn is_dummy_macro_file(file_name: &str) -> bool {
 }
 /// Converts a Rust span to a LSP location
-fn location(workspace_root: &Path, span: &DiagnosticSpan) -> lsp_types::Location {
+fn location(
-    let file_name = workspace_root.join(&span.file_name);
+    config: &DiagnosticsMapConfig,
+    workspace_root: &Path,
+    span: &DiagnosticSpan,
+) -> lsp_types::Location {
+    let file_name = resolve_path(config, workspace_root, &span.file_name);
    let uri = url_from_abs_path(&file_name);
    // FIXME: this doesn't handle UTF16 offsets correctly
@@ -58,32 +65,50 @@ fn location(workspace_root: &Path, span: &DiagnosticSpan) -> lsp_types::Location
 ///
 /// This takes locations pointing into the standard library, or generally outside the current
 /// workspace into account and tries to avoid those, in case macros are involved.
-fn primary_location(workspace_root: &Path, span: &DiagnosticSpan) -> lsp_types::Location {
+fn primary_location(
+    config: &DiagnosticsMapConfig,
+    workspace_root: &Path,
+    span: &DiagnosticSpan,
+) -> lsp_types::Location {
    let span_stack = std::iter::successors(Some(span), |span| Some(&span.expansion.as_ref()?.span));
    for span in span_stack.clone() {
-        let abs_path = workspace_root.join(&span.file_name);
+        let abs_path = resolve_path(config, workspace_root, &span.file_name);
        if !is_dummy_macro_file(&span.file_name) && abs_path.starts_with(workspace_root) {
-            return location(workspace_root, span);
+            return location(config, workspace_root, span);
        }
    }
    // Fall back to the outermost macro invocation if no suitable span comes up.
    let last_span = span_stack.last().unwrap();
-    location(workspace_root, last_span)
+    location(config, workspace_root, last_span)
 }
 /// Converts a secondary Rust span to a LSP related information
 ///
 /// If the span is unlabelled this will return `None`.
 fn diagnostic_related_information(
+    config: &DiagnosticsMapConfig,
    workspace_root: &Path,
    span: &DiagnosticSpan,
 ) -> Option<lsp_types::DiagnosticRelatedInformation> {
    let message = span.label.clone()?;
-    let location = location(workspace_root, span);
+    let location = location(config, workspace_root, span);
    Some(lsp_types::DiagnosticRelatedInformation { location, message })
 }
+/// Resolves paths applying any matching path prefix remappings, and then
+/// joining the path to the workspace root.
+fn resolve_path(config: &DiagnosticsMapConfig, workspace_root: &Path, file_name: &str) -> PathBuf {
+    match config
+        .remap_prefix
+        .iter()
+        .find_map(|(from, to)| file_name.strip_prefix(from).map(|file_name| (to, file_name)))
+    {
+        Some((to, file_name)) => workspace_root.join(format!("{}{}", to, file_name)),
+        None => workspace_root.join(file_name),
+    }
+}
 struct SubDiagnostic {
    related: lsp_types::DiagnosticRelatedInformation,
    suggested_fix: Option<lsp_ext::CodeAction>,
@@ -95,6 +120,7 @@ enum MappedRustChildDiagnostic {
 }
 fn map_rust_child_diagnostic(
+    config: &DiagnosticsMapConfig,
    workspace_root: &Path,
    rd: &flycheck::Diagnostic,
 ) -> MappedRustChildDiagnostic {
@@ -108,7 +134,7 @@ fn map_rust_child_diagnostic(
    let mut edit_map: HashMap<lsp_types::Url, Vec<lsp_types::TextEdit>> = HashMap::new();
    for &span in &spans {
        if let Some(suggested_replacement) = &span.suggested_replacement {
-            let location = location(workspace_root, span);
+            let location = location(config, workspace_root, span);
            let edit = lsp_types::TextEdit::new(location.range, suggested_replacement.clone());
            edit_map.entry(location.uri).or_default().push(edit);
        }
@@ -117,7 +143,7 @@ fn map_rust_child_diagnostic(
    if edit_map.is_empty() {
        MappedRustChildDiagnostic::SubDiagnostic(SubDiagnostic {
            related: lsp_types::DiagnosticRelatedInformation {
-                location: location(workspace_root, spans[0]),
+                location: location(config, workspace_root, spans[0]),
                message: rd.message.clone(),
            },
            suggested_fix: None,
@@ -125,7 +151,7 @@ fn map_rust_child_diagnostic(
    } else {
        MappedRustChildDiagnostic::SubDiagnostic(SubDiagnostic {
            related: lsp_types::DiagnosticRelatedInformation {
-                location: location(workspace_root, spans[0]),
+                location: location(config, workspace_root, spans[0]),
                message: rd.message.clone(),
            },
            suggested_fix: Some(lsp_ext::CodeAction {
@@ -190,7 +216,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
    let mut tags = Vec::new();
    for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
-        let related = diagnostic_related_information(workspace_root, secondary_span);
+        let related = diagnostic_related_information(config, workspace_root, secondary_span);
        if let Some(related) = related {
            subdiagnostics.push(SubDiagnostic { related, suggested_fix: None });
        }
@@ -198,7 +224,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
    let mut message = rd.message.clone();
    for child in &rd.children {
-        let child = map_rust_child_diagnostic(workspace_root, &child);
+        let child = map_rust_child_diagnostic(config, workspace_root, &child);
        match child {
            MappedRustChildDiagnostic::SubDiagnostic(sub) => {
                subdiagnostics.push(sub);
@@ -242,7 +268,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
    primary_spans
        .iter()
        .flat_map(|primary_span| {
-            let primary_location = primary_location(workspace_root, &primary_span);
+            let primary_location = primary_location(config, workspace_root, &primary_span);
            let mut message = message.clone();
            if needs_primary_span_label {
@@ -272,7 +298,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                // generated that code.
                let is_in_macro_call = i != 0;
-                let secondary_location = location(workspace_root, &span);
+                let secondary_location = location(config, workspace_root, &span);
                if secondary_location == primary_location {
                    continue;
                }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index e51532d88..0ae2758cc 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -322,6 +322,7 @@ impl GlobalState {
            let loader = &mut self.loader;
            let mem_docs = &self.mem_docs;
            let mut load = |path: &AbsPath| {
+                let _p = profile::span("GlobalState::load");
                let vfs_path = vfs::VfsPath::from(path.to_path_buf());
                if !mem_docs.contains_key(&vfs_path) {
                    let contents = loader.handle.load_sync(path);
diff --git a/crates/stdx/Cargo.toml b/crates/stdx/Cargo.toml
index d28b5e658..f78c5da7c 100644
--- a/crates/stdx/Cargo.toml
+++ b/crates/stdx/Cargo.toml
@@ -10,10 +10,15 @@ edition = "2018"
 doctest = false
 [dependencies]
+libc = "0.2.93"
 backtrace = { version = "0.3.44", optional = true }
 always-assert = { version = "0.1.2", features = ["log"] }
 # Think twice before adding anything here
+[target.'cfg(windows)'.dependencies]
+miow = "0.3.6"
+winapi = "0.3.9"
 [features]
 # Uncomment to enable for the whole crate graph
 # default = [ "backtrace" ]
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index b0a18d58d..857567a85 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -1,7 +1,8 @@
 //! Missing batteries for standard libraries.
-use std::{cmp::Ordering, ops, process, time::Instant};
+use std::{cmp::Ordering, ops, time::Instant};
 mod macros;
+pub mod process;
 pub mod panic_context;
 pub use always_assert::{always, never};
@@ -178,18 +179,30 @@ where
    start..start + len
 }
+pub fn defer<F: FnOnce()>(f: F) -> impl Drop {
+    struct D<F: FnOnce()>(Option<F>);
+    impl<F: FnOnce()> Drop for D<F> {
+        fn drop(&mut self) {
+            if let Some(f) = self.0.take() {
+                f()
+            }
+        }
+    }
+    D(Some(f))
+}
 #[repr(transparent)]
-pub struct JodChild(pub process::Child);
+pub struct JodChild(pub std::process::Child);
 impl ops::Deref for JodChild {
-    type Target = process::Child;
+    type Target = std::process::Child;
-    fn deref(&self) -> &process::Child {
+    fn deref(&self) -> &std::process::Child {
        &self.0
    }
 }
 impl ops::DerefMut for JodChild {
-    fn deref_mut(&mut self) -> &mut process::Child {
+    fn deref_mut(&mut self) -> &mut std::process::Child {
        &mut self.0
    }
 }
@@ -202,9 +215,9 @@ impl Drop for JodChild {
 }
 impl JodChild {
-    pub fn into_inner(self) -> process::Child {
+    pub fn into_inner(self) -> std::process::Child {
        // SAFETY: repr transparent
-        unsafe { std::mem::transmute::<JodChild, process::Child>(self) }
+        unsafe { std::mem::transmute::<JodChild, std::process::Child>(self) }
    }
 }
diff --git a/crates/stdx/src/process.rs b/crates/stdx/src/process.rs
new file mode 100644
index 000000000..b0fa12f76
--- /dev/null
+++ b/crates/stdx/src/process.rs
@@ -0,0 +1,238 @@
+//! Read both stdout and stderr of child without deadlocks.
+//!
+//! https://github.com/rust-lang/cargo/blob/905af549966f23a9288e9993a85d1249a5436556/crates/cargo-util/src/read2.rs
+//! https://github.com/rust-lang/cargo/blob/58a961314437258065e23cb6316dfc121d96fb71/crates/cargo-util/src/process_builder.rs#L231
+use std::{
+    io,
+    process::{Command, Output, Stdio},
+};
+pub fn streaming_output(
+    mut cmd: Command,
+    on_stdout_line: &mut dyn FnMut(&str),
+    on_stderr_line: &mut dyn FnMut(&str),
+) -> io::Result<Output> {
+    let mut stdout = Vec::new();
+    let mut stderr = Vec::new();
+    let cmd = cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
+    let status = {
+        let mut child = cmd.spawn()?;
+        let out = child.stdout.take().unwrap();
+        let err = child.stderr.take().unwrap();
+        imp::read2(out, err, &mut |is_out, data, eof| {
+            let idx = if eof {
+                data.len()
+            } else {
+                match data.iter().rposition(|b| *b == b'\n') {
+                    Some(i) => i + 1,
+                    None => return,
+                }
+            };
+            {
+                // scope for new_lines
+                let new_lines = {
+                    let dst = if is_out { &mut stdout } else { &mut stderr };
+                    let start = dst.len();
+                    let data = data.drain(..idx);
+                    dst.extend(data);
+                    &dst[start..]
+                };
+                for line in String::from_utf8_lossy(new_lines).lines() {
+                    if is_out {
+                        on_stdout_line(line)
+                    } else {
+                        on_stderr_line(line)
+                    }
+                }
+            }
+        })?;
+        child.wait()?
+    };
+    Ok(Output { status, stdout, stderr })
+}
+#[cfg(unix)]
+mod imp {
+    use std::{
+        io::{self, prelude::*},
+        mem,
+        os::unix::prelude::*,
+        process::{ChildStderr, ChildStdout},
+    };
+    pub(crate) fn read2(
+        mut out_pipe: ChildStdout,
+        mut err_pipe: ChildStderr,
+        data: &mut dyn FnMut(bool, &mut Vec<u8>, bool),
+    ) -> io::Result<()> {
+        unsafe {
+            libc::fcntl(out_pipe.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK);
+            libc::fcntl(err_pipe.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK);
+        }
+        let mut out_done = false;
+        let mut err_done = false;
+        let mut out = Vec::new();
+        let mut err = Vec::new();
+        let mut fds: [libc::pollfd; 2] = unsafe { mem::zeroed() };
+        fds[0].fd = out_pipe.as_raw_fd();
+        fds[0].events = libc::POLLIN;
+        fds[1].fd = err_pipe.as_raw_fd();
+        fds[1].events = libc::POLLIN;
+        let mut nfds = 2;
+        let mut errfd = 1;
+        while nfds > 0 {
+            // wait for either pipe to become readable using `select`
+            let r = unsafe { libc::poll(fds.as_mut_ptr(), nfds, -1) };
+            if r == -1 {
+                let err = io::Error::last_os_error();
+                if err.kind() == io::ErrorKind::Interrupted {
+                    continue;
+                }
+                return Err(err);
+            }
+            // Read as much as we can from each pipe, ignoring EWOULDBLOCK or
+            // EAGAIN. If we hit EOF, then this will happen because the underlying
+            // reader will return Ok(0), in which case we'll see `Ok` ourselves. In
+            // this case we flip the other fd back into blocking mode and read
+            // whatever's leftover on that file descriptor.
+            let handle = |res: io::Result<_>| match res {
+                Ok(_) => Ok(true),
+                Err(e) => {
+                    if e.kind() == io::ErrorKind::WouldBlock {
+                        Ok(false)
+                    } else {
+                        Err(e)
+                    }
+                }
+            };
+            if !err_done && fds[errfd].revents != 0 && handle(err_pipe.read_to_end(&mut err))? {
+                err_done = true;
+                nfds -= 1;
+            }
+            data(false, &mut err, err_done);
+            if !out_done && fds[0].revents != 0 && handle(out_pipe.read_to_end(&mut out))? {
+                out_done = true;
+                fds[0].fd = err_pipe.as_raw_fd();
+                errfd = 0;
+                nfds -= 1;
+            }
+            data(true, &mut out, out_done);
+        }
+        Ok(())
+    }
+}
+#[cfg(windows)]
+mod imp {
+    use std::{
+        io,
+        os::windows::prelude::*,
+        process::{ChildStderr, ChildStdout},
+        slice,
+    };
+    use miow::{
+        iocp::{CompletionPort, CompletionStatus},
+        pipe::NamedPipe,
+        Overlapped,
+    };
+    use winapi::shared::winerror::ERROR_BROKEN_PIPE;
+    struct Pipe<'a> {
+        dst: &'a mut Vec<u8>,
+        overlapped: Overlapped,
+        pipe: NamedPipe,
+        done: bool,
+    }
+    pub(crate) fn read2(
+        out_pipe: ChildStdout,
+        err_pipe: ChildStderr,
+        data: &mut dyn FnMut(bool, &mut Vec<u8>, bool),
+    ) -> io::Result<()> {
+        let mut out = Vec::new();
+        let mut err = Vec::new();
+        let port = CompletionPort::new(1)?;
+        port.add_handle(0, &out_pipe)?;
+        port.add_handle(1, &err_pipe)?;
+        unsafe {
+            let mut out_pipe = Pipe::new(out_pipe, &mut out);
+            let mut err_pipe = Pipe::new(err_pipe, &mut err);
+            out_pipe.read()?;
+            err_pipe.read()?;
+            let mut status = [CompletionStatus::zero(), CompletionStatus::zero()];
+            while !out_pipe.done || !err_pipe.done {
+                for status in port.get_many(&mut status, None)? {
+                    if status.token() == 0 {
+                        out_pipe.complete(status);
+                        data(true, out_pipe.dst, out_pipe.done);
+                        out_pipe.read()?;
+                    } else {
+                        err_pipe.complete(status);
+                        data(false, err_pipe.dst, err_pipe.done);
+                        err_pipe.read()?;
+                    }
+                }
+            }
+            Ok(())
+        }
+    }
+    impl<'a> Pipe<'a> {
+        unsafe fn new<P: IntoRawHandle>(p: P, dst: &'a mut Vec<u8>) -> Pipe<'a> {
+            Pipe {
+                dst,
+                pipe: NamedPipe::from_raw_handle(p.into_raw_handle()),
+                overlapped: Overlapped::zero(),
+                done: false,
+            }
+        }
+        unsafe fn read(&mut self) -> io::Result<()> {
+            let dst = slice_to_end(self.dst);
+            match self.pipe.read_overlapped(dst, self.overlapped.raw()) {
+                Ok(_) => Ok(()),
+                Err(e) => {
+                    if e.raw_os_error() == Some(ERROR_BROKEN_PIPE as i32) {
+                        self.done = true;
+                        Ok(())
+                    } else {
+                        Err(e)
+                    }
+                }
+            }
+        }
+        unsafe fn complete(&mut self, status: &CompletionStatus) {
+            let prev = self.dst.len();
+            self.dst.set_len(prev + status.bytes_transferred() as usize);
+            if status.bytes_transferred() == 0 {
+                self.done = true;
+            }
+        }
+    }
+    unsafe fn slice_to_end(v: &mut Vec<u8>) -> &mut [u8] {
+        if v.capacity() == 0 {
+            v.reserve(16);
+        }
+        if v.capacity() == v.len() {
+            v.reserve(1);
+        }
+        slice::from_raw_parts_mut(v.as_mut_ptr().add(v.len()), v.capacity() - v.len())
+    }
+}
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index a8c1a8075..556f80882 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -14,7 +14,7 @@ doctest = false
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
 rowan = "=0.13.0-pre.3"
-rustc_lexer = { version = "714.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "716.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
 once_cell = "1.3.1"
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index a153a9e1c..c9229c4e0 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -342,10 +342,10 @@ enum InsertPos {
 #[derive(Default)]
 pub struct SyntaxRewriter<'a> {
-    f: Option<Box<dyn Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a>>,
    //FIXME: add debug_assertions that all elements are in fact from the same file.
    replacements: FxHashMap<SyntaxElement, Replacement>,
    insertions: IndexMap<InsertPos, Vec<SyntaxElement>>,
+    _pd: std::marker::PhantomData<&'a ()>,
 }
 impl fmt::Debug for SyntaxRewriter<'_> {
@@ -357,14 +357,7 @@ impl fmt::Debug for SyntaxRewriter<'_> {
    }
 }
-impl<'a> SyntaxRewriter<'a> {
+impl SyntaxRewriter<'_> {
-    pub fn from_fn(f: impl Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a) -> SyntaxRewriter<'a> {
-        SyntaxRewriter {
-            f: Some(Box::new(f)),
-            replacements: FxHashMap::default(),
-            insertions: IndexMap::default(),
-        }
-    }
    pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
        let what = what.clone().into();
        let replacement = Replacement::Delete;
@@ -470,7 +463,7 @@ impl<'a> SyntaxRewriter<'a> {
    pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
        let _p = profile::span("rewrite");
-        if self.f.is_none() && self.replacements.is_empty() && self.insertions.is_empty() {
+        if self.replacements.is_empty() && self.insertions.is_empty() {
            return node.clone();
        }
        let green = self.rewrite_children(node);
@@ -495,7 +488,6 @@ impl<'a> SyntaxRewriter<'a> {
            }
        }
-        assert!(self.f.is_none());
        self.replacements
            .keys()
            .filter_map(element_to_node_or_parent)
@@ -510,10 +502,6 @@ impl<'a> SyntaxRewriter<'a> {
    }
    fn replacement(&self, element: &SyntaxElement) -> Option<Replacement> {
-        if let Some(f) = &self.f {
-            assert!(self.replacements.is_empty());
-            return f(element).map(Replacement::Single);
-        }
        self.replacements.get(element).cloned()
    }
@@ -574,7 +562,6 @@ fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, row
 impl ops::AddAssign for SyntaxRewriter<'_> {
    fn add_assign(&mut self, rhs: SyntaxRewriter) {
-        assert!(rhs.f.is_none());
        self.replacements.extend(rhs.replacements);
        for (pos, insertions) in rhs.insertions.into_iter() {
            match self.insertions.entry(pos) {
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 882e9fa09..42da09606 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -137,6 +137,17 @@ pub fn use_(visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast:
    ast_from_text(&format!("{}use {};", visibility, use_tree))
 }
+pub fn record_expr(path: ast::Path, fields: ast::RecordExprFieldList) -> ast::RecordExpr {
+    ast_from_text(&format!("fn f() {{ {} {} }}", path, fields))
+}
+pub fn record_expr_field_list(
+    fields: impl IntoIterator<Item = ast::RecordExprField>,
+) -> ast::RecordExprFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("fn f() {{ S {{ {} }} }}", fields))
+}
 pub fn record_expr_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordExprField {
    return match expr {
        Some(expr) => from_text(&format!("{}: {}", name, expr)),
@@ -294,6 +305,14 @@ pub fn wildcard_pat() -> ast::WildcardPat {
    }
 }
+pub fn literal_pat(lit: &str) -> ast::LiteralPat {
+    return from_text(lit);
+    fn from_text(text: &str) -> ast::LiteralPat {
+        ast_from_text(&format!("fn f() {{ match x {{ {} => {{}} }} }}", text))
+    }
+}
 /// Creates a tuple of patterns from an iterator of patterns.
 ///
 /// Invariant: `pats` must be length > 0
@@ -331,6 +350,21 @@ pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) ->
    }
 }
+pub fn record_pat_with_fields(path: ast::Path, fields: ast::RecordPatFieldList) -> ast::RecordPat {
+    ast_from_text(&format!("fn f({} {}: ()))", path, fields))
+}
+pub fn record_pat_field_list(
+    fields: impl IntoIterator<Item = ast::RecordPatField>,
+) -> ast::RecordPatFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("fn f(S {{ {} }}: ()))", fields))
+}
+pub fn record_pat_field(name_ref: ast::NameRef, pat: ast::Pat) -> ast::RecordPatField {
+    ast_from_text(&format!("fn f(S {{ {}: {} }}: ()))", name_ref, pat))
+}
 /// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise.
 pub fn path_pat(path: ast::Path) -> ast::Pat {
    return from_text(&path.to_string());
diff --git a/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast
index 925409bdf..e9202a612 100644
--- a/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast
@@ -1,5 +1,5 @@
-SOURCE_FILE@0..63
+SOURCE_FILE@0..102
-  FN@0..62
+  FN@0..101
    [email protected] "fn"
    [email protected] " "
    [email protected]
@@ -8,7 +8,7 @@ [email protected]
      [email protected] "("
      [email protected] ")"
    [email protected] " "
-    BLOCK_EXPR@9..62
+    BLOCK_EXPR@9..101
      [email protected] "{"
      [email protected] "\n    "
      [email protected]
@@ -70,6 +70,52 @@ [email protected]
          [email protected] "("
          [email protected] ")"
        [email protected] ";"
-      [email protected] "\n"
+      [email protected] "\n    "
-      [email protected] "}"
+      [email protected]
-  [email protected] "\n"
+        [email protected] "let"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "S"
+          [email protected] " "
+          [email protected]
+            [email protected] "{"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected] "#"
+                [email protected] "["
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "cfg"
+                [email protected]
+                  [email protected] "("
+                  [email protected] "any"
+                  [email protected]
+                    [email protected] "("
+                    [email protected] ")"
+                  [email protected] ")"
+                [email protected] "]"
+              [email protected] " "
+              [email protected]
+                [email protected] "x"
+              [email protected] ":"
+              [email protected] " "
+              [email protected]
+                [email protected]
+                  [email protected] "1"
+            [email protected] " "
+            [email protected] "}"
+        [email protected] " "
+        [email protected] "="
+        [email protected] " "
+        [email protected]
+          [email protected] "("
+          [email protected] ")"
+        [email protected] ";"
+      [email protected] "\n"
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs
index 26b1d5f89..53cfdc22d 100644
--- a/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs
+++ b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs
@@ -1,4 +1,5 @@
 fn foo() {
    let S { 0: 1 } = ();
    let S { x: 1 } = ();
+    let S { #[cfg(any())] x: 1 } = ();
 }
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 7e4488a41..16b23adc6 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -208,20 +208,26 @@ Release process is handled by `release`, `dist` and `promote` xtasks, `release`
 Additionally, it assumes that remote for `rust-analyzer` is called `upstream` (I use `origin` to point to my fork).
+`release` calls the GitHub API calls to scrape pull request comments and categorize them in the changelog.
+This step uses the `curl` and `jq` applications, which need to be available in `PATH`.
+Finally, you need to obtain a GitHub personal access token and set the `GITHUB_TOKEN` environment variable.
 Release steps:
-1. Inside rust-analyzer, run `cargo xtask release`. This will:
+1. Set the `GITHUB_TOKEN` environment variable.
+2. Inside rust-analyzer, run `cargo xtask release`. This will:
   * checkout the `release` branch
   * reset it to `upstream/nightly`
   * push it to `upstream`. This triggers GitHub Actions which:
     * runs `cargo xtask dist` to package binaries and VS Code extension
     * makes a GitHub release
     * pushes VS Code extension to the marketplace
-   * create new changelog in `rust-analyzer.github.io`
+   * call the GitHub API for PR details
-2. While the release is in progress, fill in the changelog
+   * create a new changelog in `rust-analyzer.github.io`
-3. Commit & push the changelog
+3. While the release is in progress, fill in the changelog
-4. Tweet
+4. Commit & push the changelog
-5. Inside `rust-analyzer`, run `cargo xtask promote` -- this will create a PR to rust-lang/rust updating rust-analyzer's submodule.
+5. Tweet
+6. Inside `rust-analyzer`, run `cargo xtask promote` -- this will create a PR to rust-lang/rust updating rust-analyzer's submodule.
   Self-approve the PR.
 If the GitHub Actions release fails because of a transient problem like a timeout, you can re-run the job from the Actions console.
@@ -229,7 +235,11 @@ If it fails because of something that needs to be fixed, remove the release tag
 Make sure to remove the new changelog post created when running `cargo xtask release` a second time.
 We release "nightly" every night automatically and promote the latest nightly to "stable" manually, every week.
 We don't do "patch" releases, unless something truly egregious comes up.
+To do a patch release, cherry-pick the fix on top of the current `release` branch and push the branch.
+There's no need to write a changelog for a patch release, it's OK to include the notes about the fix into the next weekly one.
+Note: we tag releases by dates, releasing a patch release on the same day should work (by overwriting a tag), but I am not 100% sure.
 ## Permissions
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index e0ee35b4e..e28423e99 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -147,6 +147,12 @@ have more false positives than usual.
 --
 List of rust-analyzer diagnostics to disable.
 --
+[[rust-analyzer.diagnostics.remapPrefix]]rust-analyzer.diagnostics.remapPrefix (default: `{}`)::
+
+--
+Map of prefixes to be substituted when parsing diagnostic file paths.
+This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.
+--
 [[rust-analyzer.diagnostics.warningsAsHint]]rust-analyzer.diagnostics.warningsAsHint (default: `[]`)::
 +
 --
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index b86e91772..54195adb7 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -429,24 +429,32 @@ However, if you use some other build system, you'll have to describe the structu
 [source,TypeScript]
 ----
 interface JsonProject {
-    /// Path to the directory with *source code* of sysroot crates.
+    /// Path to the directory with *source code* of
+    /// sysroot crates.
+    ///
+    /// It should point to the directory where std,
+    /// core, and friends can be found:
    ///
-    /// It should point to the directory where std, core, and friends can be found:
    /// https://github.com/rust-lang/rust/tree/master/library.
    ///
-    /// If provided, rust-analyzer automatically adds dependencies on sysroot
+    /// If provided, rust-analyzer automatically adds
-    /// crates. Conversely, if you omit this path, you can specify sysroot
+    /// dependencies on sysroot crates. Conversely,
-    /// dependencies yourself and, for example, have several different "sysroots" in
+    /// if you omit this path, you can specify sysroot
-    /// one graph of crates.
+    /// dependencies yourself and, for example, have
+    /// several different "sysroots" in one graph of
+    /// crates.
    sysroot_src?: string;
-    /// The set of crates comprising the current project.
+    /// The set of crates comprising the current
-    /// Must include all transitive dependencies as well as sysroot crate (libstd, libcore and such).
+    /// project. Must include all transitive
+    /// dependencies as well as sysroot crate (libstd,
+    /// libcore and such).
    crates: Crate[];
 }
 interface Crate {
-    /// Optional crate name used for display purposes, without affecting semantics.
+    /// Optional crate name used for display purposes,
-    /// See the `deps` key for semantically-significant crate names.
+    /// without affecting semantics. See the `deps`
+    /// key for semantically-significant crate names.
    display_name?: string;
    /// Path to the root module of the crate.
    root_module: string;
@@ -454,45 +462,59 @@ interface Crate {
    edition: "2015" | "2018" | "2021";
    /// Dependencies
    deps: Dep[];
-    /// Should this crate be treated as a member of current "workspace".
+    /// Should this crate be treated as a member of
+    /// current "workspace".
    ///
-    /// By default, inferred from the `root_module` (members are the crates which reside
+    /// By default, inferred from the `root_module`
-    /// inside the directory opened in the editor).
+    /// (members are the crates which reside inside
+    /// the directory opened in the editor).
    ///
-    /// Set this to `false` for things like standard library and 3rd party crates to
+    /// Set this to `false` for things like standard
-    /// enable performance optimizations (rust-analyzer assumes that non-member crates
+    /// library and 3rd party crates to enable
-    /// don't change).
+    /// performance optimizations (rust-analyzer
+    /// assumes that non-member crates don't change).
    is_workspace_member?: boolean;
-    /// Optionally specify the (super)set of `.rs` files comprising this crate.
+    /// Optionally specify the (super)set of `.rs`
+    /// files comprising this crate.
    ///
-    /// By default, rust-analyzer assumes that only files under `root_module.parent` can belong to a crate.
+    /// By default, rust-analyzer assumes that only
-    /// `include_dirs` are included recursively, unless a subdirectory is in `exclude_dirs`.
+    /// files under `root_module.parent` can belong
+    /// to a crate. `include_dirs` are included
+    /// recursively, unless a subdirectory is in
+    /// `exclude_dirs`.
    ///
    /// Different crates can share the same `source`.
    ///
-    /// If two crates share an `.rs` file in common, they *must* have the same `source`.
+    /// If two crates share an `.rs` file in common,
-    /// rust-analyzer assumes that files from one source can't refer to files in another source.
+    /// they *must* have the same `source`.
+    /// rust-analyzer assumes that files from one
+    /// source can't refer to files in another source.
    source?: {
        include_dirs: string[],
        exclude_dirs: string[],
    },
-    /// The set of cfgs activated for a given crate, like `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
+    /// The set of cfgs activated for a given crate, like
+    /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
    cfg: string[];
    /// Target triple for this Crate.
    ///
-    /// Used when running `rustc --print cfg` to get target-specific cfgs.
+    /// Used when running `rustc --print cfg`
+    /// to get target-specific cfgs.
    target?: string;
-    /// Environment variables, used for the `env!` macro
+    /// Environment variables, used for
+    /// the `env!` macro
    env: : { [key: string]: string; },
-    /// For proc-macro crates, path to compiles proc-macro (.so file).
+    /// For proc-macro crates, path to compiled
+    /// proc-macro (.so file).
    proc_macro_dylib_path?: string;
 }
 interface Dep {
    /// Index of a crate in the `crates` array.
    crate: number,
-    /// Name as should appear in the (implicit) `extern crate name` declaration.
+    /// Name as should appear in the (implicit)
+    /// `extern crate name` declaration.
    name: string,
 }
 ----
diff --git a/editors/code/package.json b/editors/code/package.json
index 06ed62d8d..fa5632f90 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -565,6 +565,11 @@
                    },
                    "uniqueItems": true
                },
+                "rust-analyzer.diagnostics.remapPrefix": {
+                    "markdownDescription": "Map of prefixes to be substituted when parsing diagnostic file paths.\nThis should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.",
+                    "default": {},
+                    "type": "object"
+                },
                "rust-analyzer.diagnostics.warningsAsHint": {
                    "markdownDescription": "List of warnings that should be displayed with info severity.\n\nThe warnings will be indicated by a blue squiggly underline in code\nand a blue icon in the `Problems Panel`.",
                    "default": [],
@@ -1195,4 +1200,4 @@
            ]
        }
    }
-}
-\ No newline at end of file
+}
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index dde5d14ee..22bb50467 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -1,4 +1,4 @@
-use std::fmt::Write;
+mod changelog;
 use xshell::{cmd, cp, pushd, read_dir, write_file};
@@ -38,42 +38,7 @@ impl flags::Release {
        let tags = cmd!("git tag --list").read()?;
        let prev_tag = tags.lines().filter(|line| is_release_tag(line)).last().unwrap();
-        let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
+        let contents = changelog::get_changelog(changelog_n, &commit, prev_tag, &today)?;
-        let mut git_log_summary = String::new();
-        for line in git_log.lines() {
-            let line = line.trim_start();
-            if let Some(p) = line.find(':') {
-                if let Ok(pr) = line[..p].parse::<u32>() {
-                    writeln!(git_log_summary, "* pr:{}[]{}", pr, &line[p + 1..]).unwrap();
-                }
-            }
-        }
-        let contents = format!(
-            "\
-= Changelog #{}
-:sectanchors:
-:page-layout: post
-Commit: commit:{}[] +
-Release: release:{}[]
-== Sponsors
-**Become a sponsor:** On https://opencollective.com/rust-analyzer/[OpenCollective] or
-https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
-== New Features
-{}
-== Fixes
-== Internal Improvements
-",
-            changelog_n, commit, today, git_log_summary
-        );
        let path = changelog_dir.join(format!("{}-changelog-{}.adoc", today, changelog_n));
        write_file(&path, &contents)?;
diff --git a/xtask/src/release/changelog.rs b/xtask/src/release/changelog.rs
new file mode 100644
index 000000000..ffcae2cf7
--- /dev/null
+++ b/xtask/src/release/changelog.rs
@@ -0,0 +1,159 @@
+use std::fmt::Write;
+use std::{env, iter};
+use anyhow::{bail, Result};
+use xshell::cmd;
+pub(crate) fn get_changelog(
+    changelog_n: usize,
+    commit: &str,
+    prev_tag: &str,
+    today: &str,
+) -> Result<String> {
+    let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
+    let mut features = String::new();
+    let mut fixes = String::new();
+    let mut internal = String::new();
+    let mut others = String::new();
+    for line in git_log.lines() {
+        let line = line.trim_start();
+        if let Some(p) = line.find(':') {
+            let pr = &line[..p];
+            if let Ok(pr_num) = pr.parse::<u32>() {
+                let accept = "Accept: application/vnd.github.v3+json";
+                let token = match env::var("GITHUB_TOKEN") {
+                    Ok(token) => token,
+                    Err(_) => bail!("Please obtain a personal access token from https://github.com/settings/tokens and set the `GITHUB_TOKEN` environment variable."),
+                };
+                let authorization = format!("Authorization: token {}", token);
+                let pr_url = "https://api.github.com/repos/rust-analyzer/rust-analyzer/issues";
+                // we don't use an HTTPS client or JSON parser to keep the build times low
+                let pr_json =
+                    cmd!("curl -s -H {accept} -H {authorization} {pr_url}/{pr}").read()?;
+                let pr_title = cmd!("jq .title").stdin(&pr_json).read()?;
+                let pr_title = unescape(&pr_title[1..pr_title.len() - 1]);
+                let pr_comment = cmd!("jq .body").stdin(pr_json).read()?;
+                let comments_json =
+                    cmd!("curl -s -H {accept} -H {authorization} {pr_url}/{pr}/comments").read()?;
+                let pr_comments = cmd!("jq .[].body").stdin(comments_json).read()?;
+                let l = iter::once(pr_comment.as_str())
+                    .chain(pr_comments.lines())
+                    .rev()
+                    .find_map(|it| {
+                        let it = unescape(&it[1..it.len() - 1]);
+                        it.lines().find_map(parse_changelog_line)
+                    })
+                    .into_iter()
+                    .next()
+                    .unwrap_or_else(|| parse_title_line(&pr_title));
+                let s = match l.kind {
+                    PrKind::Feature => &mut features,
+                    PrKind::Fix => &mut fixes,
+                    PrKind::Internal => &mut internal,
+                    PrKind::Other => &mut others,
+                    PrKind::Skip => continue,
+                };
+                writeln!(s, "* pr:{}[] {}", pr_num, l.message.as_deref().unwrap_or(&pr_title))
+                    .unwrap();
+            }
+        }
+    }
+    let contents = format!(
+        "\
+= Changelog #{}
+:sectanchors:
+:page-layout: post
+Commit: commit:{}[] +
+Release: release:{}[]
+== Sponsors
+**Become a sponsor:** On https://opencollective.com/rust-analyzer/[OpenCollective] or
+https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
+== New Features
+{}
+== Fixes
+{}
+== Internal Improvements
+{}
+== Others
+{}
+",
+        changelog_n, commit, today, features, fixes, internal, others
+    );
+    Ok(contents)
+}
+#[derive(Clone, Copy)]
+enum PrKind {
+    Feature,
+    Fix,
+    Internal,
+    Other,
+    Skip,
+}
+struct PrInfo {
+    message: Option<String>,
+    kind: PrKind,
+}
+fn unescape(s: &str) -> String {
+    s.replace(r#"\""#, "").replace(r#"\n"#, "\n").replace(r#"\r"#, "")
+}
+fn parse_changelog_line(s: &str) -> Option<PrInfo> {
+    let parts = s.splitn(3, ' ').collect::<Vec<_>>();
+    if parts.len() < 2 || parts[0] != "changelog" {
+        return None;
+    }
+    let message = parts.get(2).map(|it| it.to_string());
+    let kind = match parts[1].trim_end_matches(':') {
+        "feature" => PrKind::Feature,
+        "fix" => PrKind::Fix,
+        "internal" => PrKind::Internal,
+        "skip" => PrKind::Skip,
+        _ => {
+            let kind = PrKind::Other;
+            let message = format!("{} {}", parts[1], message.unwrap_or_default());
+            return Some(PrInfo { kind, message: Some(message) });
+        }
+    };
+    let res = PrInfo { kind, message };
+    Some(res)
+}
+fn parse_title_line(s: &str) -> PrInfo {
+    let lower = s.to_ascii_lowercase();
+    const PREFIXES: [(&str, PrKind); 5] = [
+        ("feat: ", PrKind::Feature),
+        ("feature: ", PrKind::Feature),
+        ("fix: ", PrKind::Fix),
+        ("internal: ", PrKind::Internal),
+        ("minor: ", PrKind::Skip),
+    ];
+    for &(prefix, kind) in &PREFIXES {
+        if lower.starts_with(prefix) {
+            let message = match &kind {
+                PrKind::Skip => None,
+                _ => Some(s[prefix.len()..].to_string()),
+            };
+            return PrInfo { kind, message };
+        }
+    }
+    PrInfo { kind: PrKind::Other, message: Some(s.to_string()) }
+}