24 files changed, 477 insertions, 397 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 192f0efc2..15ccf4146 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -146,9 +146,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.0.67"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
+checksum = "4a72c244c1ff497a746a7e1fb3d14bd08420ecda70c8f25c7112f2781652d787"
 
 [[package]]
 name = "cfg"
@@ -169,9 +169,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chalk-derive"
-version = "0.67.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "751a3cd9eeb24d7165e9f90daf1f10a23ffa16a7986f349027f8dfb60f51ee0c"
+checksum = "ea1552e7666a857f5417e6051ce705ea6856ab2cda39be7605e5b626fa47416b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -181,9 +181,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-ir"
-version = "0.67.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4236da905504740d3f72cc8f0509aa01321cc236208e2c33b55eda2db74bc495"
+checksum = "19d7d5f1448dbac493541e97221f7f4c32326c4c76c6ecf543daf72a1dd93e66"
 dependencies = [
  "bitflags",
  "chalk-derive",
@@ -192,9 +192,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-recursive"
-version = "0.67.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d0b123fe45a34c4cd5cb329650a0d163525d2acbe9d754a4538d3340884002e"
+checksum = "e0df406d2927321021b48acd193459dd33c913732155c93442d03f5ae8275385"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -205,9 +205,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-solve"
-version = "0.67.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c54788f0ae3b38e2bb2266f395d462d988c64f92dbd55c68219908fd1ce7ddc"
+checksum = "0cbfcd5daa5ab8b1c9e5e10e83b0ac26271480f6ae5b5f35e5b19e1f6a0e6e37"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -281,9 +281,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52fb27eab85b17fbb9f6fd667089e07d6a2eb8743d02639ee7f6a7a7729c9c94"
+checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
@@ -294,11 +294,10 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4feb231f0d4d6af81aed15928e58ecf5816aa62a2393e2c82f46973e92a9a278"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
 dependencies = [
- "autocfg",
  "cfg-if",
  "lazy_static",
 ]
@@ -426,20 +425,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2022715d62ab30faffd124d40b76f4134a550a87792276512b18d63272333394"
 
 [[package]]
-name = "fsevent"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97f347202c95c98805c216f9e1df210e8ebaec9fdb2365700a43c10797a35e63"
-dependencies = [
- "bitflags",
- "fsevent-sys",
-]
-
-[[package]]
 name = "fsevent-sys"
-version = "3.1.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca6f5e6817058771c10f0eb0f05ddf1e35844266f972004fe8e4b21fda295bd5"
+checksum = "5c0e564d24da983c053beff1bb7178e237501206840a3e6bf4e267b9e8ae734a"
 dependencies = [
  "libc",
 ]
@@ -776,9 +765,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.94"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
+checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36"
 
 [[package]]
 name = "libloading"
@@ -881,18 +870,18 @@ checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
 
 [[package]]
 name = "memmap2"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "397d1a6d6d0563c0f5462bbdae662cf6c784edf5e828e40c7257f85d82bf56dd"
+checksum = "723e3ebdcdc5c023db1df315364573789f8857c11b631a2fdfad7c00f5c046b4"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memoffset"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83fb6581e8ed1f85fd45c116db8405483899489e38406156c25eb743554361d"
+checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
 dependencies = [
  "autocfg",
 ]
@@ -940,14 +929,13 @@ dependencies = [
 
 [[package]]
 name = "notify"
-version = "5.0.0-pre.8"
+version = "5.0.0-pre.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bbbcd078f1f00ddb7a9abe70b96e91229b44b0b3afdec610f8e5137f8f014b"
+checksum = "b89869d77edd64db917d7903abeadc166f93686b342c56cc0ca51acb68441d09"
 dependencies = [
  "bitflags",
  "crossbeam-channel",
  "filetime",
- "fsevent",
  "fsevent-sys",
  "inotify",
  "libc",
@@ -1360,9 +1348,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "720.0.0"
+version = "721.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a025b453b0ae85335336f991f920ca9af5c0dc851171cb9035a16cea5619e9b2"
+checksum = "2ba1f60e2942dc7dc5ea64edeaae01cfba2303871b14936e1af0f54d5420b3d1"
 dependencies = [
  "unicode-xid",
 ]
@@ -1828,9 +1816,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"
+checksum = "33717dca7ac877f497014e10d73f3acf948c342bee31b5ca7892faf94ccc6b49"
 dependencies = [
  "tinyvec",
 ]
@@ -1958,18 +1946,18 @@ dependencies = [
 
 [[package]]
 name = "xshell"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb15bb1b41eb14efe628006294c294e10c366e03a0283b9c2063fc27d97934c6"
+checksum = "c640362f1b150e186b76e88606e4b01a7b2f1d56cc50fcc184ddb683fb567c23"
 dependencies = [
  "xshell-macros",
 ]
 
 [[package]]
 name = "xshell-macros"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf7ed94a2c75b9bcc57031229be2b57ee47ba71122f71aabef8610ec66a97e52"
+checksum = "0607c095c96c1d8420ce4a018a0954fb15d73d5eb59b521a05a0f04cffc05059"
 
 [[package]]
 name = "xtask"
diff --git a/Cargo.toml b/Cargo.toml
index 498cf7d62..32ba3923b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,10 +3,6 @@ resolver = "2"
 members = ["xtask/", "lib/*", "crates/*"]
 
 [profile.dev]
-# We do want incremental builds, but they are broken at the moment :(
-# https://github.com/rust-lang/rust/issues/85003#issuecomment-833796289
-incremental = false
-
 # Disabling debug info speeds up builds a bunch,
 # and we don't rely on it for debugging that much.
 debug = 0
@@ -21,14 +17,9 @@ text-size.opt-level = 3
 miniz_oxide.opt-level = 3
 
 [profile.release]
-# We do want incremental release builds, but they are broken at the moment :(
-# https://github.com/rust-lang/rust/issues/85003#issuecomment-833796289
-incremental = false
+incremental = true
 debug = 0 # Set this to 1 or 2 to get more useful backtraces in debugger.
 
-[profile.test]
-incremental = false
-
 [patch.'crates-io']
 # rowan = { path = "../rowan" }
 
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index a9994082a..c3d02424d 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.67", default-features = false }
-chalk-ir = "0.67"
-chalk-recursive = "0.67"
+chalk-solve = { version = "0.68", default-features = false }
+chalk-ir = "0.68"
+chalk-recursive = "0.68"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index b108fd559..4e042bf42 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -383,7 +383,7 @@ pub(crate) fn associated_ty_data_query(
     // Lower bounds -- we could/should maybe move this to a separate query in `lower`
     let type_alias_data = db.type_alias_data(type_alias);
     let generic_params = generics(db.upcast(), type_alias.into());
-    let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
+    // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
     let ctx = crate::TyLoweringContext::new(db, &resolver)
         .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
@@ -396,8 +396,10 @@ pub(crate) fn associated_ty_data_query(
         .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
         .collect();
 
-    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
-    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses };
+    // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
+    //        (rust-analyzer#9052)
+    // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
+    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
     let datum = AssociatedTyDatum {
         trait_id: to_chalk_trait_id(trait_),
         id,
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 7c0ff2170..49add4ab9 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -161,7 +161,7 @@ mod result {
 }
 
 #[test]
-fn infer_tryv2() {
+fn infer_try_trait_v2() {
     check_types(
         r#"
 //- /main.rs crate:main deps:core
@@ -172,26 +172,41 @@ fn test() {
 } //^ i32
 
 //- /core.rs crate:core
-#[prelude_import] use ops::*;
 mod ops {
-    trait Try {
-        type Output;
-        type Residual;
+    mod try_trait {
+        pub trait Try: FromResidual {
+            type Output;
+            type Residual;
+        }
+        pub trait FromResidual<R = <Self as Try>::Residual> {}
     }
+
+    pub use self::try_trait::FromResidual;
+    pub use self::try_trait::Try;
+}
+
+mov convert {
+    pub trait From<T> {}
+    impl<T> From<T> for T {}
 }
 
 #[prelude_import] use result::*;
 mod result {
-    enum Infallible {}
-    enum Result<O, E> {
+    use crate::convert::From;
+    use crate::ops::{Try, FromResidual};
+
+    pub enum Infallible {}
+    pub enum Result<O, E> {
         Ok(O),
         Err(E)
     }
 
-    impl<O, E> crate::ops::Try for Result<O, E> {
+    impl<O, E> Try for Result<O, E> {
         type Output = O;
         type Error = Result<Infallible, E>;
     }
+
+    impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F> {}
 }
 "#,
     );
diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index 78154bf3e..151bf3783 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -18,7 +18,7 @@ pub(crate) mod unqualified_path;
 
 use std::iter;
 
-use hir::{known, ModPath, ScopeDef, Type};
+use hir::known;
 use ide_db::SymbolKind;
 
 use crate::{
@@ -69,12 +69,17 @@ impl Completions {
         items.into_iter().for_each(|item| self.add(item.into()))
     }
 
-    pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
+    pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &hir::Type) {
         let item = render_field(RenderContext::new(ctx), field, ty);
         self.add(item);
     }
 
-    pub(crate) fn add_tuple_field(&mut self, ctx: &CompletionContext, field: usize, ty: &Type) {
+    pub(crate) fn add_tuple_field(
+        &mut self,
+        ctx: &CompletionContext,
+        field: usize,
+        ty: &hir::Type,
+    ) {
         let item = render_tuple_field(RenderContext::new(ctx), field, ty);
         self.add(item);
     }
@@ -89,8 +94,8 @@ impl Completions {
     pub(crate) fn add_resolution(
         &mut self,
         ctx: &CompletionContext,
-        local_name: String,
-        resolution: &ScopeDef,
+        local_name: hir::Name,
+        resolution: &hir::ScopeDef,
     ) {
         if let Some(item) = render_resolution(RenderContext::new(ctx), local_name, resolution) {
             self.add(item);
@@ -100,7 +105,7 @@ impl Completions {
     pub(crate) fn add_macro(
         &mut self,
         ctx: &CompletionContext,
-        name: Option<String>,
+        name: Option<hir::Name>,
         macro_: hir::MacroDef,
     ) {
         let name = match name {
@@ -116,7 +121,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         func: hir::Function,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         if let Some(item) = render_fn(RenderContext::new(ctx), None, local_name, func) {
             self.add(item)
@@ -127,7 +132,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         func: hir::Function,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         if let Some(item) = render_method(RenderContext::new(ctx), None, local_name, func) {
             self.add(item)
@@ -149,7 +154,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        path: ModPath,
+        path: hir::ModPath,
     ) {
         if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)) {
             self.add(item);
@@ -183,7 +188,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        path: ModPath,
+        path: hir::ModPath,
     ) {
         let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
         self.add(item);
@@ -193,7 +198,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
         self.add(item);
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index 13d5b90c9..76d926157 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -219,8 +219,7 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     ),
     attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
     attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
-    // FIXME: resolve through macro resolution?
-    attr("global_allocator", None, None).prefer_inner(),
+    attr("global_allocator", None, None),
     attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
     attr("inline", Some("inline"), Some("inline")),
     attr("link", None, None),
@@ -239,7 +238,7 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     attr("no_mangle", None, None),
     attr("no_std", None, None).prefer_inner(),
     attr("non_exhaustive", None, None),
-    attr("panic_handler", None, None).prefer_inner(),
+    attr("panic_handler", None, None),
     attr(r#"path = "…""#, Some("path"), Some(r#"path ="${0:path}""#)),
     attr("proc_macro", None, None),
     attr("proc_macro_attribute", None, None),
@@ -609,6 +608,7 @@ mod tests {
                 at export_name = "…"
                 at link_name = "…"
                 at link_section = "…"
+                at global_allocator
                 at used
             "#]],
         );
@@ -732,9 +732,9 @@ mod tests {
     }
 
     #[test]
-    fn complete_attribute_on_expr() {
+    fn complete_attribute_on_fn() {
         check(
-            r#"fn main() { #[$0] foo() }"#,
+            r#"#[$0] fn main() {}"#,
             expect![[r#"
                 at allow(…)
                 at cfg(…)
@@ -742,10 +742,35 @@ mod tests {
                 at deny(…)
                 at forbid(…)
                 at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at export_name = "…"
+                at link_name = "…"
+                at link_section = "…"
+                at cold
+                at ignore = "…"
+                at inline
+                at must_use
+                at panic_handler
+                at proc_macro
+                at proc_macro_derive(…)
+                at proc_macro_attribute
+                at should_panic
+                at target_feature = "…"
+                at test
+                at track_caller
             "#]],
         );
+    }
+
+    #[test]
+    fn complete_attribute_on_expr() {
         check(
-            r#"fn main() { #[$0] foo(); }"#,
+            r#"fn main() { #[$0] foo() }"#,
             expect![[r#"
                 at allow(…)
                 at cfg(…)
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 0ea558489..cb90e8a3e 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -128,4 +128,19 @@ fn outer(text: String) {
             "#]],
         )
     }
+
+    #[test]
+    fn completes_non_ident_pat_param() {
+        check(
+            r#"
+struct Bar { bar: u32 }
+
+fn foo(Bar { bar }: Bar) {}
+fn foo2($0) {}
+"#,
+            expect![[r#"
+                bn Bar { bar }: Bar
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index e71a04b6e..0d035c611 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -4,7 +4,10 @@ use std::iter;
 
 use syntax::{SyntaxKind, T};
 
-use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
+use crate::{
+    patterns::ImmediateLocation, CompletionContext, CompletionItem, CompletionItemKind,
+    CompletionKind, Completions,
+};
 
 pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     // complete keyword "crate" in use stmt
@@ -44,7 +47,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         cov_mark::hit!(no_keyword_completion_in_comments);
         return;
     }
-    if ctx.record_lit_syntax.is_some() {
+    if matches!(ctx.completion_location, Some(ImmediateLocation::RecordExpr(_))) {
         cov_mark::hit!(no_keyword_completion_in_record_lit);
         return;
     }
@@ -55,7 +58,6 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     let expects_item = ctx.expects_item();
 
     if ctx.has_impl_or_trait_prev_sibling() {
-        // FIXME this also incorrectly shows up after a complete trait/impl
         add_keyword("where", "where ");
         return;
     }
@@ -77,11 +79,8 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword("pub", "pub ");
     }
 
-    if expects_item || expects_assoc_item || has_block_expr_parent || ctx.is_match_arm {
-        add_keyword("unsafe", "unsafe ");
-    }
-
     if expects_item || expects_assoc_item || has_block_expr_parent {
+        add_keyword("unsafe", "unsafe ");
         add_keyword("fn", "fn $1($2) {\n    $0\n}");
         add_keyword("const", "const $0");
         add_keyword("type", "type $0");
@@ -103,6 +102,9 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     }
 
     if ctx.expects_expression() {
+        if !has_block_expr_parent {
+            add_keyword("unsafe", "unsafe {\n    $0\n}");
+        }
         add_keyword("match", "match $1 {\n    $0\n}");
         add_keyword("while", "while $1 {\n    $0\n}");
         add_keyword("while let", "while let $1 = $2 {\n    $0\n}");
@@ -574,6 +576,7 @@ pub mod future {
         check(
             r#"fn main() { let _ = $0 }"#,
             expect![[r#"
+                kw unsafe
                 kw match
                 kw while
                 kw while let
@@ -634,6 +637,7 @@ fn foo() {
 }
 "#,
             expect![[r#"
+                kw unsafe
                 kw match
                 kw while
                 kw while let
diff --git a/crates/ide_completion/src/completions/lifetime.rs b/crates/ide_completion/src/completions/lifetime.rs
index 5f6285b84..8ccccb646 100644
--- a/crates/ide_completion/src/completions/lifetime.rs
+++ b/crates/ide_completion/src/completions/lifetime.rs
@@ -16,15 +16,14 @@ pub(crate) fn complete_lifetime(acc: &mut Completions, ctx: &CompletionContext)
         (Some(lt), Some(lp)) if lp == lt.clone() => return,
         (Some(_), Some(lp)) => {
             lp_string = lp.to_string();
-            Some(&lp_string)
+            Some(&*lp_string)
         }
         _ => None,
     };
 
     ctx.scope.process_all_names(&mut |name, res| {
         if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
-            let name = name.to_string();
-            if param_lifetime != Some(&name) {
+            if param_lifetime != Some(&*name.to_string()) {
                 acc.add_resolution(ctx, name, &res);
             }
         }
@@ -41,7 +40,7 @@ pub(crate) fn complete_label(acc: &mut Completions, ctx: &CompletionContext) {
     }
     ctx.scope.process_all_names(&mut |name, res| {
         if let ScopeDef::Label(_) = res {
-            acc.add_resolution(ctx, name.to_string(), &res);
+            acc.add_resolution(ctx, name, &res);
         }
     });
 }
diff --git a/crates/ide_completion/src/completions/macro_in_item_position.rs b/crates/ide_completion/src/completions/macro_in_item_position.rs
index ec57aee30..202e71215 100644
--- a/crates/ide_completion/src/completions/macro_in_item_position.rs
+++ b/crates/ide_completion/src/completions/macro_in_item_position.rs
@@ -11,11 +11,11 @@ pub(crate) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 
     ctx.scope.process_all_names(&mut |name, res| {
         if let hir::ScopeDef::MacroDef(mac) = res {
-            acc.add_macro(ctx, Some(name.to_string()), mac);
+            acc.add_macro(ctx, Some(name.clone()), mac);
         }
         // FIXME: This should be done in qualified_path/unqualified_path instead?
         if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
-            acc.add_resolution(ctx, name.to_string(), &res);
+            acc.add_resolution(ctx, name, &res);
         }
     })
 }
diff --git a/crates/ide_completion/src/completions/mod_.rs b/crates/ide_completion/src/completions/mod_.rs
index 4f9415736..6a5746fb9 100644
--- a/crates/ide_completion/src/completions/mod_.rs
+++ b/crates/ide_completion/src/completions/mod_.rs
@@ -9,14 +9,14 @@ use ide_db::{
 };
 use rustc_hash::FxHashSet;
 
-use crate::CompletionItem;
+use crate::{patterns::ImmediateLocation, CompletionItem};
 
 use crate::{context::CompletionContext, item::CompletionKind, Completions};
 
 /// Complete mod declaration, i.e. `mod $0 ;`
 pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let mod_under_caret = match &ctx.mod_declaration_under_caret {
-        Some(mod_under_caret) if mod_under_caret.item_list().is_none() => mod_under_caret,
+    let mod_under_caret = match &ctx.completion_location {
+        Some(ImmediateLocation::ModDeclaration(mod_under_caret)) => mod_under_caret,
         _ => return None,
     };
 
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index b84e9a967..8a728c67e 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -51,7 +51,7 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
             _ => false,
         };
         if add_resolution {
-            acc.add_resolution(ctx, name.to_string(), &res);
+            acc.add_resolution(ctx, name, &res);
         }
     });
 }
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index 7a0e1ead3..de58ce1cd 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -1,6 +1,6 @@
 //! Completion of paths, i.e. `some::prefix::$0`.
 
-use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
+use hir::HasVisibility;
 use rustc_hash::FxHashSet;
 use syntax::AstNode;
 
@@ -21,14 +21,14 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
     };
     let context_module = ctx.scope.module();
     if ctx.expects_assoc_item() {
-        if let PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
+        if let hir::PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
-                if let ScopeDef::MacroDef(macro_def) = def {
-                    acc.add_macro(ctx, Some(name.to_string()), macro_def);
+                if let hir::ScopeDef::MacroDef(macro_def) = def {
+                    acc.add_macro(ctx, Some(name.clone()), macro_def);
                 }
-                if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
-                    acc.add_resolution(ctx, name.to_string(), &def);
+                if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
+                    acc.add_resolution(ctx, name, &def);
                 }
             }
         }
@@ -42,11 +42,11 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
     });
 
     match resolution {
-        PathResolution::Def(hir::ModuleDef::Module(module)) => {
+        hir::PathResolution::Def(hir::ModuleDef::Module(module)) => {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
                 if ctx.use_item_syntax.is_some() {
-                    if let ScopeDef::Unknown = def {
+                    if let hir::ScopeDef::Unknown = def {
                         if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
                             if name_ref.syntax().text() == name.to_string().as_str() {
                                 // for `use self::foo$0`, don't suggest `foo` as a completion
@@ -57,20 +57,20 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     }
                 }
 
-                acc.add_resolution(ctx, name.to_string(), &def);
+                acc.add_resolution(ctx, name, &def);
             }
         }
-        PathResolution::Def(def @ hir::ModuleDef::Adt(_))
-        | PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_))
-        | PathResolution::Def(def @ hir::ModuleDef::BuiltinType(_)) => {
-            if let hir::ModuleDef::Adt(Adt::Enum(e)) = def {
+        hir::PathResolution::Def(def @ hir::ModuleDef::Adt(_))
+        | hir::PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_))
+        | hir::PathResolution::Def(def @ hir::ModuleDef::BuiltinType(_)) => {
+            if let hir::ModuleDef::Adt(hir::Adt::Enum(e)) = def {
                 add_enum_variants(ctx, acc, e);
             }
             let ty = match def {
                 hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
                 hir::ModuleDef::TypeAlias(a) => {
                     let ty = a.ty(ctx.db);
-                    if let Some(Adt::Enum(e)) = ty.as_adt() {
+                    if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
                         cov_mark::hit!(completes_variant_through_alias);
                         add_enum_variants(ctx, acc, e);
                     }
@@ -117,7 +117,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 });
             }
         }
-        PathResolution::Def(hir::ModuleDef::Trait(t)) => {
+        hir::PathResolution::Def(hir::ModuleDef::Trait(t)) => {
             // Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
             for item in t.items(ctx.db) {
                 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
@@ -130,15 +130,15 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 }
             }
         }
-        PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
+        hir::PathResolution::TypeParam(_) | hir::PathResolution::SelfType(_) => {
             if let Some(krate) = ctx.krate {
                 let ty = match resolution {
-                    PathResolution::TypeParam(param) => param.ty(ctx.db),
-                    PathResolution::SelfType(impl_def) => impl_def.self_ty(ctx.db),
+                    hir::PathResolution::TypeParam(param) => param.ty(ctx.db),
+                    hir::PathResolution::SelfType(impl_def) => impl_def.self_ty(ctx.db),
                     _ => return,
                 };
 
-                if let Some(Adt::Enum(e)) = ty.as_adt() {
+                if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
                     add_enum_variants(ctx, acc, e);
                 }
 
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index e1526b70b..227c08d01 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -2,21 +2,21 @@
 use ide_db::{helpers::FamousDefs, SymbolKind};
 use syntax::ast::Expr;
 
-use crate::{item::CompletionKind, CompletionContext, CompletionItem, Completions};
+use crate::{
+    item::CompletionKind, patterns::ImmediateLocation, CompletionContext, CompletionItem,
+    Completions,
+};
 
 pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
-        (None, None) => return None,
-        (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
-        (Some(record_pat), _) => ctx.sema.record_pattern_missing_fields(record_pat),
-        (_, Some(record_lit)) => {
-            let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_lit.clone()));
+    let missing_fields = match &ctx.completion_location {
+        Some(ImmediateLocation::RecordExpr(record_expr)) => {
+            let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_expr.clone()));
             let default_trait = FamousDefs(&ctx.sema, ctx.krate).core_default_Default();
             let impl_default_trait = default_trait
                 .zip(ty)
                 .map_or(false, |(default_trait, ty)| ty.impls_trait(ctx.db, default_trait, &[]));
 
-            let missing_fields = ctx.sema.record_literal_missing_fields(record_lit);
+            let missing_fields = ctx.sema.record_literal_missing_fields(record_expr);
             if impl_default_trait && !missing_fields.is_empty() {
                 let completion_text = "..Default::default()";
                 let mut item = CompletionItem::new(
@@ -32,6 +32,10 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 
             missing_fields
         }
+        Some(ImmediateLocation::RecordPat(record_pat)) => {
+            ctx.sema.record_pattern_missing_fields(record_pat)
+        }
+        _ => return None,
     };
 
     for (field, ty) in missing_fields {
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index ede07f605..9db8516d0 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -14,10 +14,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     if ctx.expects_assoc_item() {
         ctx.scope.process_all_names(&mut |name, def| {
             if let ScopeDef::MacroDef(macro_def) = def {
-                acc.add_macro(ctx, Some(name.to_string()), macro_def);
+                acc.add_macro(ctx, Some(name.clone()), macro_def);
             }
             if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
-                acc.add_resolution(ctx, name.to_string(), &def);
+                acc.add_resolution(ctx, name, &def);
             }
         });
         return;
@@ -27,7 +27,7 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         cov_mark::hit!(only_completes_modules_in_import);
         ctx.scope.process_all_names(&mut |name, res| {
             if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
-                acc.add_resolution(ctx, name.to_string(), &res);
+                acc.add_resolution(ctx, name, &res);
             }
         });
         return;
@@ -45,7 +45,7 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
             cov_mark::hit!(skip_lifetime_completion);
             return;
         }
-        acc.add_resolution(ctx, name.to_string(), &res);
+        acc.add_resolution(ctx, name, &res);
     });
 }
 
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 8d6440cb2..7c46c815d 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -18,7 +18,7 @@ use text_edit::Indel;
 use crate::{
     patterns::{
         determine_location, determine_prev_sibling, for_is_prev2, inside_impl_trait_block,
-        is_in_loop_body, is_match_arm, previous_token, ImmediateLocation, ImmediatePrevSibling,
+        is_in_loop_body, previous_token, ImmediateLocation, ImmediatePrevSibling,
     },
     CompletionConfig,
 };
@@ -54,11 +54,6 @@ pub(crate) struct CompletionContext<'a> {
     /// The parent impl of the cursor position if it exists.
     pub(super) impl_def: Option<ast::Impl>,
 
-    /// RecordExpr the token is a field of
-    pub(super) record_lit_syntax: Option<ast::RecordExpr>,
-    /// RecordPat the token is a field of
-    pub(super) record_pat_syntax: Option<ast::RecordPat>,
-
     // potentially set if we are completing a lifetime
     pub(super) lifetime_syntax: Option<ast::Lifetime>,
     pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
@@ -71,6 +66,7 @@ pub(crate) struct CompletionContext<'a> {
 
     pub(super) completion_location: Option<ImmediateLocation>,
     pub(super) prev_sibling: Option<ImmediatePrevSibling>,
+    pub(super) attribute_under_caret: Option<ast::Attr>,
 
     /// FIXME: `ActiveParameter` is string-based, which is very very wrong
     pub(super) active_parameter: Option<ActiveParameter>,
@@ -95,14 +91,10 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_macro_call: bool,
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
-    pub(super) attribute_under_caret: Option<ast::Attr>,
-    pub(super) mod_declaration_under_caret: Option<ast::Module>,
     pub(super) locals: Vec<(String, Local)>,
 
-    // keyword patterns
     pub(super) previous_token: Option<SyntaxToken>,
     pub(super) in_loop_body: bool,
-    pub(super) is_match_arm: bool,
     pub(super) incomplete_let: bool,
 
     no_completion_required: bool,
@@ -157,8 +149,6 @@ impl<'a> CompletionContext<'a> {
             lifetime_param_syntax: None,
             function_def: None,
             use_item_syntax: None,
-            record_lit_syntax: None,
-            record_pat_syntax: None,
             impl_def: None,
             active_parameter: ActiveParameter::at(db, position),
             is_label_ref: false,
@@ -176,15 +166,13 @@ impl<'a> CompletionContext<'a> {
             is_macro_call: false,
             is_path_type: false,
             has_type_args: false,
-            attribute_under_caret: None,
-            mod_declaration_under_caret: None,
             previous_token: None,
             in_loop_body: false,
             completion_location: None,
             prev_sibling: None,
-            is_match_arm: false,
             no_completion_required: false,
             incomplete_let: false,
+            attribute_under_caret: None,
             locals,
         };
 
@@ -227,7 +215,6 @@ impl<'a> CompletionContext<'a> {
                 break;
             }
         }
-        ctx.fill_keyword_patterns(&speculative_file, offset);
         ctx.fill(&original_file, speculative_file, offset);
         Some(ctx)
     }
@@ -311,31 +298,13 @@ impl<'a> CompletionContext<'a> {
     }
 
     pub(crate) fn is_path_disallowed(&self) -> bool {
-        self.record_lit_syntax.is_some()
-            || self.record_pat_syntax.is_some()
-            || self.attribute_under_caret.is_some()
-            || self.mod_declaration_under_caret.is_some()
-    }
-
-    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
-        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
-        let syntax_element = NodeOrToken::Token(fake_ident_token);
-        self.previous_token = previous_token(syntax_element.clone());
-        self.in_loop_body = is_in_loop_body(syntax_element.clone());
-        self.is_match_arm = is_match_arm(syntax_element.clone());
-
-        self.mod_declaration_under_caret =
-            find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
-                .filter(|module| module.item_list().is_none());
-        self.incomplete_let =
-            syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
-                it.syntax().text_range().end() == syntax_element.text_range().end()
-            });
-
-        let inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
-        let fn_is_prev = self.previous_token_is(T![fn]);
-        let for_is_prev2 = for_is_prev2(syntax_element.clone());
-        self.no_completion_required = (fn_is_prev && !inside_impl_trait_block) || for_is_prev2;
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::Attribute(_))
+                | Some(ImmediateLocation::ModDeclaration(_))
+                | Some(ImmediateLocation::RecordPat(_))
+                | Some(ImmediateLocation::RecordExpr(_))
+        ) || self.attribute_under_caret.is_some()
     }
 
     fn fill_impl_def(&mut self) {
@@ -453,25 +422,43 @@ impl<'a> CompletionContext<'a> {
         file_with_fake_ident: SyntaxNode,
         offset: TextSize,
     ) {
+        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
+        let syntax_element = NodeOrToken::Token(fake_ident_token);
+        self.previous_token = previous_token(syntax_element.clone());
+        self.attribute_under_caret = syntax_element.ancestors().find_map(ast::Attr::cast);
+        self.no_completion_required = {
+            let inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
+            let fn_is_prev = self.previous_token_is(T![fn]);
+            let for_is_prev2 = for_is_prev2(syntax_element.clone());
+            (fn_is_prev && !inside_impl_trait_block) || for_is_prev2
+        };
+        self.in_loop_body = is_in_loop_body(syntax_element.clone());
+
+        self.incomplete_let =
+            syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
+                it.syntax().text_range().end() == syntax_element.text_range().end()
+            });
+
         let (expected_type, expected_name) = self.expected_type_and_name();
         self.expected_type = expected_type;
         self.expected_name = expected_name;
-        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
+
         let name_like = match find_node_at_offset(&&file_with_fake_ident, offset) {
             Some(it) => it,
             None => return,
         };
-        self.completion_location = determine_location(&name_like);
+        self.completion_location =
+            determine_location(&self.sema, original_file, offset, &name_like);
         self.prev_sibling = determine_prev_sibling(&name_like);
         match name_like {
             ast::NameLike::Lifetime(lifetime) => {
                 self.classify_lifetime(original_file, lifetime, offset);
             }
             ast::NameLike::NameRef(name_ref) => {
-                self.classify_name_ref(original_file, name_ref, offset);
+                self.classify_name_ref(original_file, name_ref);
             }
             ast::NameLike::Name(name) => {
-                self.classify_name(original_file, name, offset);
+                self.classify_name(name);
             }
         }
     }
@@ -505,7 +492,7 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
-    fn classify_name(&mut self, original_file: &SyntaxNode, name: ast::Name, offset: TextSize) {
+    fn classify_name(&mut self, name: ast::Name) {
         if let Some(bind_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
             self.is_pat_or_const = Some(PatternRefutability::Refutable);
             // if any of these is here our bind pat can't be a const pat anymore
@@ -543,28 +530,12 @@ impl<'a> CompletionContext<'a> {
 
             self.fill_impl_def();
         }
+
         self.is_param |= is_node::<ast::Param>(name.syntax());
-        if ast::RecordPatField::for_field_name(&name).is_some() {
-            self.record_pat_syntax =
-                self.sema.find_node_at_offset_with_macros(&original_file, offset);
-        }
     }
 
-    fn classify_name_ref(
-        &mut self,
-        original_file: &SyntaxNode,
-        name_ref: ast::NameRef,
-        offset: TextSize,
-    ) {
+    fn classify_name_ref(&mut self, original_file: &SyntaxNode, name_ref: ast::NameRef) {
         self.fill_impl_def();
-        if ast::RecordExprField::for_field_name(&name_ref).is_some() {
-            self.record_lit_syntax =
-                self.sema.find_node_at_offset_with_macros(original_file, offset);
-        }
-        if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
-            self.record_pat_syntax =
-                self.sema.find_node_at_offset_with_macros(&original_file, offset);
-        }
 
         self.name_ref_syntax =
             find_node_at_offset(original_file, name_ref.syntax().text_range().start());
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index caf0ef39f..26516046b 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -1,15 +1,18 @@
 //! Patterns telling us certain facts about current syntax element, they are used in completion context
 
+use hir::Semantics;
+use ide_db::RootDatabase;
 use syntax::{
     algo::non_trivia_sibling,
     ast::{self, LoopBodyOwner},
-    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
+    match_ast, AstNode, Direction, SyntaxElement,
     SyntaxKind::*,
-    SyntaxNode, SyntaxToken, T,
+    SyntaxNode, SyntaxToken, TextSize, T,
 };
 
 #[cfg(test)]
 use crate::test_utils::{check_pattern_is_applicable, check_pattern_is_not_applicable};
+
 /// Direct parent container of the cursor position
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub(crate) enum ImmediatePrevSibling {
@@ -19,7 +22,7 @@ pub(crate) enum ImmediatePrevSibling {
 }
 
 /// Direct parent container of the cursor position
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum ImmediateLocation {
     Use,
     Impl,
@@ -29,10 +32,24 @@ pub(crate) enum ImmediateLocation {
     IdentPat,
     BlockExpr,
     ItemList,
+    // Fake file ast node
+    Attribute(ast::Attr),
+    // Fake file ast node
+    ModDeclaration(ast::Module),
+    // Original file ast node
+    /// The record expr of the field name we are completing
+    RecordExpr(ast::RecordExpr),
+    // Original file ast node
+    /// The record pat of the field name we are completing
+    RecordPat(ast::RecordPat),
 }
 
 pub(crate) fn determine_prev_sibling(name_like: &ast::NameLike) -> Option<ImmediatePrevSibling> {
-    let node = maximize_name_ref(name_like)?;
+    let node = match name_like {
+        ast::NameLike::NameRef(name_ref) => maximize_name_ref(name_ref),
+        ast::NameLike::Name(n) => n.syntax().clone(),
+        ast::NameLike::Lifetime(lt) => lt.syntax().clone(),
+    };
     let node = match node.parent().and_then(ast::MacroCall::cast) {
         // When a path is being typed after the name of a trait/type of an impl it is being
         // parsed as a macro, so when the trait/impl has a block following it an we are between the
@@ -77,8 +94,37 @@ pub(crate) fn determine_prev_sibling(name_like: &ast::NameLike) -> Option<Immedi
     Some(res)
 }
 
-pub(crate) fn determine_location(name_like: &ast::NameLike) -> Option<ImmediateLocation> {
-    let node = maximize_name_ref(name_like)?;
+pub(crate) fn determine_location(
+    sema: &Semantics<RootDatabase>,
+    original_file: &SyntaxNode,
+    offset: TextSize,
+    name_like: &ast::NameLike,
+) -> Option<ImmediateLocation> {
+    let node = match name_like {
+        ast::NameLike::NameRef(name_ref) => {
+            if ast::RecordExprField::for_field_name(&name_ref).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordExpr);
+            }
+            if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordPat);
+            }
+            maximize_name_ref(name_ref)
+        }
+        ast::NameLike::Name(name) => {
+            if ast::RecordPatField::for_field_name(&name).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordPat);
+            }
+            name.syntax().clone()
+        }
+        ast::NameLike::Lifetime(lt) => lt.syntax().clone(),
+    };
+
     let parent = match node.parent() {
         Some(parent) => match ast::MacroCall::cast(parent.clone()) {
             // When a path is being typed in an (Assoc)ItemList the parser will always emit a macro_call.
@@ -103,6 +149,7 @@ pub(crate) fn determine_location(name_like: &ast::NameLike) -> Option<ImmediateL
             }
         }
     };
+
     let res = match_ast! {
         match parent {
             ast::IdentPat(_it) => ImmediateLocation::IdentPat,
@@ -117,36 +164,34 @@ pub(crate) fn determine_location(name_like: &ast::NameLike) -> Option<ImmediateL
                 Some(TRAIT) => ImmediateLocation::Trait,
                 _ => return None,
             },
+            ast::Module(it) => if it.item_list().is_none() {
+                    ImmediateLocation::ModDeclaration(it)
+                } else {
+                    return None
+            },
+            ast::Attr(it) => ImmediateLocation::Attribute(it),
             _ => return None,
         }
     };
     Some(res)
 }
 
-fn maximize_name_ref(name_like: &ast::NameLike) -> Option<SyntaxNode> {
-    // First walk the element we are completing up to its highest node that has the same text range
-    // as the element so that we can check in what context it immediately lies. We only do this for
-    // NameRef -> Path as that's the only thing that makes sense to being "expanded" semantically.
-    // We only wanna do this if the NameRef is the last segment of the path.
-    let node = match name_like {
-        ast::NameLike::NameRef(name_ref) => {
-            if let Some(segment) = name_ref.syntax().parent().and_then(ast::PathSegment::cast) {
-                let p = segment.parent_path();
-                if p.parent_path().is_none() {
-                    p.syntax()
-                        .ancestors()
-                        .take_while(|it| it.text_range() == p.syntax().text_range())
-                        .last()?
-                } else {
-                    return None;
-                }
-            } else {
-                return None;
+fn maximize_name_ref(name_ref: &ast::NameRef) -> SyntaxNode {
+    // Maximize a nameref to its enclosing path if its the last segment of said path
+    if let Some(segment) = name_ref.syntax().parent().and_then(ast::PathSegment::cast) {
+        let p = segment.parent_path();
+        if p.parent_path().is_none() {
+            if let Some(it) = p
+                .syntax()
+                .ancestors()
+                .take_while(|it| it.text_range() == p.syntax().text_range())
+                .last()
+            {
+                return it;
             }
         }
-        it @ ast::NameLike::Name(_) | it @ ast::NameLike::Lifetime(_) => it.syntax().clone(),
-    };
-    Some(node)
+    }
+    name_ref.syntax().clone()
 }
 
 pub(crate) fn inside_impl_trait_block(element: SyntaxElement) -> bool {
@@ -167,18 +212,6 @@ fn test_inside_impl_trait_block() {
     check_pattern_is_not_applicable(r"impl A { fn f$0 }", inside_impl_trait_block);
 }
 
-pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
-        && previous_sibling_or_ancestor_sibling(element)
-            .and_then(|it| it.into_token())
-            .filter(|it| it.kind() == FAT_ARROW)
-            .is_some()
-}
-#[test]
-fn test_is_match_arm() {
-    check_pattern_is_applicable(r"fn my_fn() { match () { () => m$0 } }", is_match_arm);
-}
-
 pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
     element.into_token().and_then(|it| previous_non_trivia_token(it))
 }
@@ -216,10 +249,6 @@ pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
         .is_some()
 }
 
-pub(crate) fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
-    element.ancestors().skip_while(|it| it.text_range() == element.text_range()).next()
-}
-
 fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
     let mut token = token.prev_token();
     while let Some(inner) = token.clone() {
@@ -232,31 +261,25 @@ fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
     None
 }
 
-fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
-    let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
-    if let Some(sibling) = token_sibling {
-        Some(sibling)
-    } else {
-        // if not trying to find first ancestor which has such a sibling
-        let range = element.text_range();
-        let top_node = element.ancestors().take_while(|it| it.text_range() == range).last()?;
-        let prev_sibling_node = top_node.ancestors().find(|it| {
-            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
-        })?;
-        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use syntax::algo::find_node_at_offset;
+
+    use crate::test_utils::position;
+
     use super::*;
 
     fn check_location(code: &str, loc: impl Into<Option<ImmediateLocation>>) {
-        check_pattern_is_applicable(code, |e| {
-            let name = &e.parent().and_then(ast::NameLike::cast).expect("Expected a namelike");
-            assert_eq!(determine_location(name), loc.into());
-            true
-        });
+        let (db, pos) = position(code);
+
+        let sema = Semantics::new(&db);
+        let original_file = sema.parse(pos.file_id);
+
+        let name_like = find_node_at_offset(original_file.syntax(), pos.offset).unwrap();
+        assert_eq!(
+            determine_location(&sema, original_file.syntax(), pos.offset, &name_like),
+            loc.into()
+        );
     }
 
     fn check_prev_sibling(code: &str, sibling: impl Into<Option<ImmediatePrevSibling>>) {
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 91300c56e..425dd0247 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -10,9 +10,7 @@ pub(crate) mod type_alias;
 
 mod builder_ext;
 
-use hir::{
-    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
-};
+use hir::{AsAssocItem, HasAttrs, HirDisplay};
 use ide_db::{
     helpers::{item_name, SnippetCap},
     RootDatabase, SymbolKind,
@@ -21,31 +19,30 @@ use syntax::TextRange;
 
 use crate::{
     item::{CompletionRelevanceTypeMatch, ImportEdit},
+    render::{enum_variant::render_variant, function::render_fn, macro_::render_macro},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
 };
 
-use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
-
 pub(crate) fn render_field<'a>(
     ctx: RenderContext<'a>,
     field: hir::Field,
-    ty: &Type,
+    ty: &hir::Type,
 ) -> CompletionItem {
-    Render::new(ctx).add_field(field, ty)
+    Render::new(ctx).render_field(field, ty)
 }
 
 pub(crate) fn render_tuple_field<'a>(
     ctx: RenderContext<'a>,
     field: usize,
-    ty: &Type,
+    ty: &hir::Type,
 ) -> CompletionItem {
-    Render::new(ctx).add_tuple_field(field, ty)
+    Render::new(ctx).render_tuple_field(field, ty)
 }
 
 pub(crate) fn render_resolution<'a>(
     ctx: RenderContext<'a>,
-    local_name: String,
-    resolution: &ScopeDef,
+    local_name: hir::Name,
+    resolution: &hir::ScopeDef,
 ) -> Option<CompletionItem> {
     Render::new(ctx).render_resolution(local_name, None, resolution)
 }
@@ -54,12 +51,12 @@ pub(crate) fn render_resolution_with_import<'a>(
     ctx: RenderContext<'a>,
     import_edit: ImportEdit,
 ) -> Option<CompletionItem> {
-    let resolution = ScopeDef::from(import_edit.import.original_item);
+    let resolution = hir::ScopeDef::from(import_edit.import.original_item);
     let local_name = match resolution {
-        ScopeDef::ModuleDef(ModuleDef::Function(f)) => f.name(ctx.completion.db).to_string(),
-        ScopeDef::ModuleDef(ModuleDef::Const(c)) => c.name(ctx.completion.db)?.to_string(),
-        ScopeDef::ModuleDef(ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db).to_string(),
-        _ => item_name(ctx.db(), import_edit.import.original_item)?.to_string(),
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::Function(f)) => f.name(ctx.completion.db),
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::Const(c)) => c.name(ctx.completion.db)?,
+        hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
+        _ => item_name(ctx.db(), import_edit.import.original_item)?,
     };
     Render::new(ctx).render_resolution(local_name, Some(import_edit), &resolution).map(
         |mut item| {
@@ -113,7 +110,7 @@ impl<'a> RenderContext<'a> {
             || assoc.containing_trait(db).map(|trait_| self.is_deprecated(trait_)).unwrap_or(false)
     }
 
-    fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
+    fn docs(&self, node: impl HasAttrs) -> Option<hir::Documentation> {
         node.docs(self.db())
     }
 }
@@ -129,14 +126,11 @@ impl<'a> Render<'a> {
         Render { ctx }
     }
 
-    fn add_field(&mut self, field: hir::Field, ty: &Type) -> CompletionItem {
+    fn render_field(&self, field: hir::Field, ty: &hir::Type) -> CompletionItem {
         let is_deprecated = self.ctx.is_deprecated(field);
-        let name = field.name(self.ctx.db());
-        let mut item = CompletionItem::new(
-            CompletionKind::Reference,
-            self.ctx.source_range(),
-            name.to_string(),
-        );
+        let name = field.name(self.ctx.db()).to_string();
+        let mut item =
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name.clone());
         item.kind(SymbolKind::Field)
             .detail(ty.display(self.ctx.db()).to_string())
             .set_documentation(field.docs(self.ctx.db()))
@@ -144,7 +138,7 @@ impl<'a> Render<'a> {
 
         item.set_relevance(CompletionRelevance {
             type_match: compute_type_match(self.ctx.completion, ty),
-            exact_name_match: compute_exact_name_match(self.ctx.completion, name.to_string()),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, &name),
             ..CompletionRelevance::default()
         });
 
@@ -157,7 +151,7 @@ impl<'a> Render<'a> {
         item.build()
     }
 
-    fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
+    fn render_tuple_field(&self, field: usize, ty: &hir::Type) -> CompletionItem {
         let mut item = CompletionItem::new(
             CompletionKind::Reference,
             self.ctx.source_range(),
@@ -171,71 +165,82 @@ impl<'a> Render<'a> {
 
     fn render_resolution(
         self,
-        local_name: String,
+        local_name: hir::Name,
         import_to_add: Option<ImportEdit>,
-        resolution: &ScopeDef,
+        resolution: &hir::ScopeDef,
     ) -> Option<CompletionItem> {
         let _p = profile::span("render_resolution");
         use hir::ModuleDef::*;
 
         let completion_kind = match resolution {
-            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
+            hir::ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
             _ => CompletionKind::Reference,
         };
 
         let kind = match resolution {
-            ScopeDef::ModuleDef(Function(func)) => {
+            hir::ScopeDef::ModuleDef(Function(func)) => {
                 return render_fn(self.ctx, import_to_add, Some(local_name), *func);
             }
-            ScopeDef::ModuleDef(Variant(_)) if self.ctx.completion.is_pat_or_const.is_some() => {
+            hir::ScopeDef::ModuleDef(Variant(_))
+                if self.ctx.completion.is_pat_or_const.is_some() =>
+            {
                 CompletionItemKind::SymbolKind(SymbolKind::Variant)
             }
-            ScopeDef::ModuleDef(Variant(var)) => {
+            hir::ScopeDef::ModuleDef(Variant(var)) => {
                 let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                 return Some(item);
             }
-            ScopeDef::MacroDef(mac) => {
+            hir::ScopeDef::MacroDef(mac) => {
                 let item = render_macro(self.ctx, import_to_add, local_name, *mac);
                 return item;
             }
 
-            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::SymbolKind(SymbolKind::Module),
-            ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
+            hir::ScopeDef::ModuleDef(Module(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::Module)
+            }
+            hir::ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
                 hir::Adt::Struct(_) => SymbolKind::Struct,
                 hir::Adt::Union(_) => SymbolKind::Union,
                 hir::Adt::Enum(_) => SymbolKind::Enum,
             }),
-            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
-            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
-            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
-            ScopeDef::ModuleDef(TypeAlias(..)) => {
+            hir::ScopeDef::ModuleDef(Const(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::Const)
+            }
+            hir::ScopeDef::ModuleDef(Static(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::Static)
+            }
+            hir::ScopeDef::ModuleDef(Trait(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::Trait)
+            }
+            hir::ScopeDef::ModuleDef(TypeAlias(..)) => {
                 CompletionItemKind::SymbolKind(SymbolKind::TypeAlias)
             }
-            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
-            ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {
+            hir::ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
+            hir::ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {
                 hir::GenericParam::TypeParam(_) => SymbolKind::TypeParam,
                 hir::GenericParam::LifetimeParam(_) => SymbolKind::LifetimeParam,
                 hir::GenericParam::ConstParam(_) => SymbolKind::ConstParam,
             }),
-            ScopeDef::Local(..) => CompletionItemKind::SymbolKind(SymbolKind::Local),
-            ScopeDef::Label(..) => CompletionItemKind::SymbolKind(SymbolKind::Label),
-            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => {
+            hir::ScopeDef::Local(..) => CompletionItemKind::SymbolKind(SymbolKind::Local),
+            hir::ScopeDef::Label(..) => CompletionItemKind::SymbolKind(SymbolKind::Label),
+            hir::ScopeDef::AdtSelfType(..) | hir::ScopeDef::ImplSelfType(..) => {
                 CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
             }
-            ScopeDef::Unknown => {
+            hir::ScopeDef::Unknown => {
                 let mut item = CompletionItem::new(
                     CompletionKind::Reference,
                     self.ctx.source_range(),
-                    local_name,
+                    local_name.to_string(),
                 );
                 item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add);
                 return Some(item.build());
             }
         };
 
+        let local_name = local_name.to_string();
         let mut item =
             CompletionItem::new(completion_kind, self.ctx.source_range(), local_name.clone());
-        if let ScopeDef::Local(local) = resolution {
+        if let hir::ScopeDef::Local(local) = resolution {
             let ty = local.ty(self.ctx.db());
             if !ty.is_unknown() {
                 item.detail(ty.display(self.ctx.db()).to_string());
@@ -260,8 +265,10 @@ impl<'a> Render<'a> {
         {
             if let Some(cap) = self.ctx.snippet_cap() {
                 let has_non_default_type_params = match resolution {
-                    ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(self.ctx.db()),
-                    ScopeDef::ModuleDef(TypeAlias(it)) => {
+                    hir::ScopeDef::ModuleDef(Adt(it)) => {
+                        it.has_non_default_type_params(self.ctx.db())
+                    }
+                    hir::ScopeDef::ModuleDef(TypeAlias(it)) => {
                         it.has_non_default_type_params(self.ctx.db())
                     }
                     _ => false,
@@ -281,26 +288,26 @@ impl<'a> Render<'a> {
         Some(item.build())
     }
 
-    fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
+    fn docs(&self, resolution: &hir::ScopeDef) -> Option<hir::Documentation> {
         use hir::ModuleDef::*;
         match resolution {
-            ScopeDef::ModuleDef(Module(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(Adt(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(Variant(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(Const(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(Static(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(Trait(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Module(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Adt(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Variant(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Const(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Static(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(Trait(it)) => it.docs(self.ctx.db()),
+            hir::ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(self.ctx.db()),
             _ => None,
         }
     }
 
-    fn is_deprecated(&self, resolution: &ScopeDef) -> bool {
+    fn is_deprecated(&self, resolution: &hir::ScopeDef) -> bool {
         match resolution {
-            ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it),
-            ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it),
-            ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it),
-            ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it),
+            hir::ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it),
+            hir::ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it),
+            hir::ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it),
+            hir::ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it),
             _ => false,
         }
     }
@@ -327,21 +334,23 @@ fn compute_type_match(
     }
 }
 
-fn compute_exact_name_match(ctx: &CompletionContext, completion_name: impl Into<String>) -> bool {
-    let completion_name = completion_name.into();
+fn compute_exact_name_match(ctx: &CompletionContext, completion_name: &str) -> bool {
     ctx.expected_name.as_ref().map_or(false, |name| name.text() == completion_name)
 }
 
-fn compute_ref_match(ctx: &CompletionContext, completion_ty: &hir::Type) -> Option<Mutability> {
+fn compute_ref_match(
+    ctx: &CompletionContext,
+    completion_ty: &hir::Type,
+) -> Option<hir::Mutability> {
     let expected_type = ctx.expected_type.as_ref()?;
     if completion_ty != expected_type {
         let expected_type_without_ref = expected_type.remove_ref()?;
         if completion_ty.autoderef(ctx.db).any(|deref_ty| deref_ty == expected_type_without_ref) {
             cov_mark::hit!(suggest_ref);
             let mutability = if expected_type.is_mutable_reference() {
-                Mutability::Mut
+                hir::Mutability::Mut
             } else {
-                Mutability::Shared
+                hir::Mutability::Shared
             };
             return Some(mutability);
         };
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index 0c0c71134..28f056e77 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -1,6 +1,8 @@
 //! Renderer for `enum` variants.
 
-use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
+use std::iter;
+
+use hir::{HasAttrs, HirDisplay};
 use ide_db::SymbolKind;
 use itertools::Itertools;
 
@@ -13,9 +15,9 @@ use crate::{
 pub(crate) fn render_variant<'a>(
     ctx: RenderContext<'a>,
     import_to_add: Option<ImportEdit>,
-    local_name: Option<String>,
+    local_name: Option<hir::Name>,
     variant: hir::Variant,
-    path: Option<ModPath>,
+    path: Option<hir::ModPath>,
 ) -> CompletionItem {
     let _p = profile::span("render_enum_variant");
     EnumRender::new(ctx, local_name, variant, path).render(import_to_add)
@@ -24,42 +26,45 @@ pub(crate) fn render_variant<'a>(
 #[derive(Debug)]
 struct EnumRender<'a> {
     ctx: RenderContext<'a>,
-    name: String,
+    name: hir::Name,
     variant: hir::Variant,
-    path: Option<ModPath>,
-    qualified_name: String,
-    short_qualified_name: String,
-    variant_kind: StructKind,
+    path: Option<hir::ModPath>,
+    qualified_name: hir::ModPath,
+    short_qualified_name: hir::ModPath,
+    variant_kind: hir::StructKind,
 }
 
 impl<'a> EnumRender<'a> {
     fn new(
         ctx: RenderContext<'a>,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
         variant: hir::Variant,
-        path: Option<ModPath>,
+        path: Option<hir::ModPath>,
     ) -> EnumRender<'a> {
-        let name = local_name.unwrap_or_else(|| variant.name(ctx.db()).to_string());
+        let name = local_name.unwrap_or_else(|| variant.name(ctx.db()));
         let variant_kind = variant.kind(ctx.db());
 
         let (qualified_name, short_qualified_name) = match &path {
             Some(path) => {
-                let full = path.to_string();
-                let segments = path.segments();
-                let short = segments[segments.len().saturating_sub(2)..].iter().join("::");
-                (full, short)
+                let short = hir::ModPath::from_segments(
+                    hir::PathKind::Plain,
+                    path.segments().iter().skip(path.segments().len().saturating_sub(2)).cloned(),
+                );
+                (path.clone(), short)
             }
-            None => (name.to_string(), name.to_string()),
+            None => (
+                hir::ModPath::from_segments(hir::PathKind::Plain, iter::once(name.clone())),
+                hir::ModPath::from_segments(hir::PathKind::Plain, iter::once(name.clone())),
+            ),
         };
 
         EnumRender { ctx, name, variant, path, qualified_name, short_qualified_name, variant_kind }
     }
-
     fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
         let mut item = CompletionItem::new(
             CompletionKind::Reference,
             self.ctx.source_range(),
-            self.qualified_name.clone(),
+            self.qualified_name.to_string(),
         );
         item.kind(SymbolKind::Variant)
             .set_documentation(self.variant.docs(self.ctx.db()))
@@ -67,12 +72,16 @@ impl<'a> EnumRender<'a> {
             .add_import(import_to_add)
             .detail(self.detail());
 
-        if self.variant_kind == StructKind::Tuple {
+        if self.variant_kind == hir::StructKind::Tuple {
             cov_mark::hit!(inserts_parens_for_tuple_enums);
             let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
-            item.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
+            item.add_call_parens(
+                self.ctx.completion,
+                self.short_qualified_name.to_string(),
+                params,
+            );
         } else if self.path.is_some() {
-            item.lookup_by(self.short_qualified_name);
+            item.lookup_by(self.short_qualified_name.to_string());
         }
 
         let ty = self.variant.parent_enum(self.ctx.completion.db).ty(self.ctx.completion.db);
@@ -96,11 +105,11 @@ impl<'a> EnumRender<'a> {
             .map(|field| (field.name(self.ctx.db()), field.ty(self.ctx.db())));
 
         match self.variant_kind {
-            StructKind::Tuple | StructKind::Unit => format!(
+            hir::StructKind::Tuple | hir::StructKind::Unit => format!(
                 "({})",
                 detail_types.map(|(_, t)| t.display(self.ctx.db()).to_string()).format(", ")
             ),
-            StructKind::Record => format!(
+            hir::StructKind::Record => format!(
                 "{{ {} }}",
                 detail_types
                     .map(|(n, t)| format!("{}: {}", n, t.display(self.ctx.db()).to_string()))
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index d681e2c91..63bd66926 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -1,6 +1,6 @@
 //! Renderer for function calls.
 
-use hir::{HasSource, HirDisplay, Type};
+use hir::{HasSource, HirDisplay};
 use ide_db::SymbolKind;
 use itertools::Itertools;
 use syntax::ast::Fn;
@@ -16,7 +16,7 @@ use crate::{
 pub(crate) fn render_fn<'a>(
     ctx: RenderContext<'a>,
     import_to_add: Option<ImportEdit>,
-    local_name: Option<String>,
+    local_name: Option<hir::Name>,
     fn_: hir::Function,
 ) -> Option<CompletionItem> {
     let _p = profile::span("render_fn");
@@ -26,7 +26,7 @@ pub(crate) fn render_fn<'a>(
 pub(crate) fn render_method<'a>(
     ctx: RenderContext<'a>,
     import_to_add: Option<ImportEdit>,
-    local_name: Option<String>,
+    local_name: Option<hir::Name>,
     fn_: hir::Function,
 ) -> Option<CompletionItem> {
     let _p = profile::span("render_method");
@@ -45,11 +45,11 @@ struct FunctionRender<'a> {
 impl<'a> FunctionRender<'a> {
     fn new(
         ctx: RenderContext<'a>,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
         fn_: hir::Function,
         is_method: bool,
     ) -> Option<FunctionRender<'a>> {
-        let name = local_name.unwrap_or_else(|| fn_.name(ctx.db()).to_string());
+        let name = local_name.unwrap_or_else(|| fn_.name(ctx.db())).to_string();
         let ast_node = fn_.source(ctx.db())?.value;
 
         Some(FunctionRender { ctx, name, func: fn_, ast_node, is_method })
@@ -74,7 +74,7 @@ impl<'a> FunctionRender<'a> {
         let ret_type = self.func.ret_type(self.ctx.db());
         item.set_relevance(CompletionRelevance {
             type_match: compute_type_match(self.ctx.completion, &ret_type),
-            exact_name_match: compute_exact_name_match(self.ctx.completion, self.name.clone()),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, &self.name),
             ..CompletionRelevance::default()
         });
 
@@ -129,7 +129,7 @@ impl<'a> FunctionRender<'a> {
         format!("-> {}", ret_ty.display(self.ctx.db()))
     }
 
-    fn add_arg(&self, arg: &str, ty: &Type) -> String {
+    fn add_arg(&self, arg: &str, ty: &hir::Type) -> String {
         if let Some(derefed_ty) = ty.remove_ref() {
             for (name, local) in self.ctx.completion.locals.iter() {
                 if name == arg && local.ty(self.ctx.db()) == derefed_ty {
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index b90fd3890..0dfba8acc 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -1,6 +1,6 @@
 //! Renderer for macro invocations.
 
-use hir::{Documentation, HasSource};
+use hir::HasSource;
 use ide_db::SymbolKind;
 use syntax::display::macro_label;
 
@@ -12,7 +12,7 @@ use crate::{
 pub(crate) fn render_macro<'a>(
     ctx: RenderContext<'a>,
     import_to_add: Option<ImportEdit>,
-    name: String,
+    name: hir::Name,
     macro_: hir::MacroDef,
 ) -> Option<CompletionItem> {
     let _p = profile::span("render_macro");
@@ -24,13 +24,14 @@ struct MacroRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
     macro_: hir::MacroDef,
-    docs: Option<Documentation>,
+    docs: Option<hir::Documentation>,
     bra: &'static str,
     ket: &'static str,
 }
 
 impl<'a> MacroRender<'a> {
-    fn new(ctx: RenderContext<'a>, name: String, macro_: hir::MacroDef) -> MacroRender<'a> {
+    fn new(ctx: RenderContext<'a>, name: hir::Name, macro_: hir::MacroDef) -> MacroRender<'a> {
+        let name = name.to_string();
         let docs = ctx.docs(macro_);
         let docs_str = docs.as_ref().map_or("", |s| s.as_str());
         let (bra, ket) = guess_macro_braces(&name, docs_str);
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 3f3134562..14dbbb20d 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -11,9 +11,9 @@ use hir::{
     db::{AstDatabase, DefDatabase, HirDatabase},
     AssocItem, Crate, Function, HasSource, HirDisplay, ModuleDef,
 };
-use hir_def::FunctionId;
+use hir_def::{body::BodySourceMap, expr::ExprId, FunctionId};
 use hir_ty::{TyExt, TypeWalk};
-use ide::{AnalysisHost, RootDatabase};
+use ide::{Analysis, AnalysisHost, LineCol, RootDatabase};
 use ide_db::base_db::{
     salsa::{self, ParallelDatabase},
     SourceDatabaseExt,
@@ -25,7 +25,7 @@ use rayon::prelude::*;
 use rustc_hash::FxHashSet;
 use stdx::format_to;
 use syntax::AstNode;
-use vfs::Vfs;
+use vfs::{Vfs, VfsPath};
 
 use crate::cli::{
     load_cargo::{load_workspace_at, LoadCargoConfig},
@@ -191,6 +191,7 @@ impl AnalysisStatsCmd {
         let mut num_exprs_unknown = 0;
         let mut num_exprs_partially_unknown = 0;
         let mut num_type_mismatches = 0;
+        let analysis = host.analysis();
         for f in funcs.iter().copied() {
             let name = f.name(db);
             let full_name = f
@@ -220,7 +221,7 @@ impl AnalysisStatsCmd {
             }
             bar.set_message(&msg);
             let f_id = FunctionId::from(f);
-            let body = db.body(f_id.into());
+            let (body, sm) = db.body_with_source_map(f_id.into());
             let inference_result = db.infer(f_id.into());
             let (previous_exprs, previous_unknown, previous_partially_unknown) =
                 (num_exprs, num_exprs_unknown, num_exprs_partially_unknown);
@@ -229,6 +230,22 @@ impl AnalysisStatsCmd {
                 num_exprs += 1;
                 if ty.is_unknown() {
                     num_exprs_unknown += 1;
+                    if verbosity.is_spammy() {
+                        if let Some((path, start, end)) =
+                            expr_syntax_range(db, &analysis, vfs, &sm, expr_id)
+                        {
+                            bar.println(format!(
+                                "{} {}:{}-{}:{}: Unknown type",
+                                path,
+                                start.line + 1,
+                                start.col,
+                                end.line + 1,
+                                end.col,
+                            ));
+                        } else {
+                            bar.println(format!("{}: Unknown type", name,));
+                        }
+                    }
                 } else {
                     let mut is_partially_unknown = false;
                     ty.walk(&mut |ty| {
@@ -242,20 +259,9 @@ impl AnalysisStatsCmd {
                 }
                 if self.only.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single expression
-                    let (_, sm) = db.body_with_source_map(f_id.into());
-                    let src = sm.expr_syntax(expr_id);
-                    if let Ok(src) = src {
-                        let node = {
-                            let root = db.parse_or_expand(src.file_id).unwrap();
-                            src.value.to_node(&root)
-                        };
-                        let original_file = src.file_id.original_file(db);
-                        let line_index = host.analysis().file_line_index(original_file).unwrap();
-                        let text_range = node.syntax().text_range();
-                        let (start, end) = (
-                            line_index.line_col(text_range.start()),
-                            line_index.line_col(text_range.end()),
-                        );
+                    if let Some((_, start, end)) =
+                        expr_syntax_range(db, &analysis, vfs, &sm, expr_id)
+                    {
                         bar.println(format!(
                             "{}:{}-{}:{}: {}",
                             start.line + 1,
@@ -271,22 +277,9 @@ impl AnalysisStatsCmd {
                 if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                     num_type_mismatches += 1;
                     if verbosity.is_verbose() {
-                        let (_, sm) = db.body_with_source_map(f_id.into());
-                        let src = sm.expr_syntax(expr_id);
-                        if let Ok(src) = src {
-                            // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
-                            // But also, we should just turn the type mismatches into diagnostics and provide these
-                            let root = db.parse_or_expand(src.file_id).unwrap();
-                            let node = src.map(|e| e.to_node(&root).syntax().clone());
-                            let original_range = node.as_ref().original_file_range(db);
-                            let path = vfs.file_path(original_range.file_id);
-                            let line_index =
-                                host.analysis().file_line_index(original_range.file_id).unwrap();
-                            let text_range = original_range.range;
-                            let (start, end) = (
-                                line_index.line_col(text_range.start()),
-                                line_index.line_col(text_range.end()),
-                            );
+                        if let Some((path, start, end)) =
+                            expr_syntax_range(db, &analysis, vfs, &sm, expr_id)
+                        {
                             bar.println(format!(
                                 "{} {}:{}-{}:{}: Expected {}, got {}",
                                 path,
@@ -319,6 +312,7 @@ impl AnalysisStatsCmd {
             }
             bar.inc(1);
         }
+
         bar.finish_and_clear();
         eprintln!(
             "  exprs: {}, ??ty: {} ({}%), ?ty: {} ({}%), !ty: {}",
@@ -340,6 +334,31 @@ impl AnalysisStatsCmd {
     }
 }
 
+fn expr_syntax_range(
+    db: &RootDatabase,
+    analysis: &Analysis,
+    vfs: &Vfs,
+    sm: &BodySourceMap,
+    expr_id: ExprId,
+) -> Option<(VfsPath, LineCol, LineCol)> {
+    let src = sm.expr_syntax(expr_id);
+    if let Ok(src) = src {
+        // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
+        // But also, we should just turn the type mismatches into diagnostics and provide these
+        let root = db.parse_or_expand(src.file_id).unwrap();
+        let node = src.map(|e| e.to_node(&root).syntax().clone());
+        let original_range = node.as_ref().original_file_range(db);
+        let path = vfs.file_path(original_range.file_id);
+        let line_index = analysis.file_line_index(original_range.file_id).unwrap();
+        let text_range = original_range.range;
+        let (start, end) =
+            (line_index.line_col(text_range.start()), line_index.line_col(text_range.end()));
+        Some((path, start, end))
+    } else {
+        None
+    }
+}
+
 fn shuffle<T>(rng: &mut Rand32, slice: &mut [T]) {
     for i in 0..slice.len() {
         randomize_first(rng, &mut slice[i..]);
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index a6c294245..2106732cd 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.6"
-rustc_lexer = { version = "720.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "721.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
 once_cell = "1.3.1"