53 files changed, 1269 insertions, 1174 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 31a850797..1051c4ec6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,9 +26,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c0df63cb2955042487fad3aefd2c6e3ae7389ac5dc1beb28921de0b69f779d4"
+checksum = "68803225a7b13e47191bab76f2687382b60d259e8cf37f6e1893658b84bb9479"
 
 [[package]]
 name = "anymap"
@@ -685,9 +685,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
+checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
 dependencies = [
  "autocfg",
  "hashbrown",
@@ -1105,9 +1105,9 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 
 [[package]]
 name = "perf-event"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "273069d0b956939ba75e8b5663328b9b7f0dc2e262b3306c6be66c4d87e2240a"
+checksum = "b7a1c2678a77d65edf773bd900f5b87f0944ac3421949842a2c6a4efe42d6c66"
 dependencies = [
  "libc",
  "perf-event-open-sys",
@@ -1990,18 +1990,18 @@ dependencies = [
 
 [[package]]
 name = "xshell"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed0728d188f2ae530490b7d92435728aba53c6aed06d07e1951da9bd4c1d0798"
+checksum = "ed373ede30cea03e8c0af22f48ee1ba80efbf06fec8b4746977e6ee703878de0"
 dependencies = [
  "xshell-macros",
 ]
 
 [[package]]
 name = "xshell-macros"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "367f903cc3f8bc4f4b2400d47dfa6c9e3e121ffb51a30cf0fb67a72c0a0f9617"
+checksum = "7f6af9f8119104697b0105989a73c578ce33f922d9d6f3dae0e8ae3d538db321"
 
 [[package]]
 name = "xtask"
diff --git a/crates/assists/src/handlers/generate_function.rs b/crates/assists/src/handlers/generate_function.rs
index 758188a42..f4cf155b6 100644
--- a/crates/assists/src/handlers/generate_function.rs
+++ b/crates/assists/src/handlers/generate_function.rs
@@ -145,7 +145,7 @@ impl FunctionBuilder {
             self.type_params,
             self.params,
             fn_body,
-            Some(make::ret_type(make::ty("()"))),
+            Some(make::ret_type(make::ty_unit())),
         );
         let leading_ws;
         let trailing_ws;
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index acce2e7e7..19ce2482f 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -428,8 +428,8 @@ struct Test {}
                 at Hash
                 at PartialEq
                 at PartialEq, Eq
-                at PartialEq, Eq, PartialOrd, Ord
                 at PartialEq, PartialOrd
+                at PartialEq, Eq, PartialOrd, Ord
             "#]],
         );
     }
@@ -457,10 +457,10 @@ struct Test {}
                 at Clone, Copy
                 at Debug
                 at Default
-                at Eq
-                at Eq, PartialOrd, Ord
                 at Hash
+                at Eq
                 at PartialOrd
+                at Eq, PartialOrd, Ord
             "#]],
         )
     }
@@ -472,14 +472,14 @@ struct Test {}
             expect![[r#"
                 at allow(…)
                 at automatically_derived
-                at cfg(…)
                 at cfg_attr(…)
+                at cfg(…)
                 at cold
                 at deny(…)
                 at deprecated = "…"
                 at derive(…)
-                at doc = "…"
                 at export_name = "…"
+                at doc = "…"
                 at forbid(…)
                 at ignore = "…"
                 at inline(…)
@@ -518,15 +518,15 @@ struct Test {}
             expect![[r#"
                 at allow(…)
                 at automatically_derived
-                at cfg(…)
                 at cfg_attr(…)
+                at cfg(…)
                 at cold
                 at crate_name = ""
                 at deny(…)
                 at deprecated = "…"
                 at derive(…)
-                at doc = "…"
                 at export_name = "…"
+                at doc = "…"
                 at feature(…)
                 at forbid(…)
                 at global_allocator
@@ -538,8 +538,8 @@ struct Test {}
                 at macro_export
                 at macro_use
                 at must_use = "…"
-                at no_implicit_prelude
                 at no_link
+                at no_implicit_prelude
                 at no_main
                 at no_mangle
                 at no_std
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
index c9875045a..551ef1771 100644
--- a/crates/completion/src/completions/dot.rs
+++ b/crates/completion/src/completions/dot.rs
@@ -82,8 +82,8 @@ impl S {
 fn foo(s: S) { s.<|> }
 "#,
             expect![[r#"
-                me bar() fn bar(&self)
                 fd foo   u32
+                me bar() fn bar(&self)
             "#]],
         );
     }
@@ -98,8 +98,8 @@ impl S {
 }
 "#,
             expect![[r#"
-                me foo()     fn foo(self)
                 fd the_field (u32,)
+                me foo()     fn foo(self)
             "#]],
         )
     }
@@ -114,8 +114,8 @@ impl A {
 }
 "#,
             expect![[r#"
-                me foo()     fn foo(&self)
                 fd the_field (u32, i32)
+                me foo()     fn foo(&self)
             "#]],
         )
     }
@@ -147,8 +147,8 @@ mod inner {
 fn foo(a: inner::A) { a.<|> }
 "#,
             expect![[r#"
-                fd crate_field u32
                 fd pub_field   u32
+                fd crate_field u32
                 fd super_field u32
             "#]],
         );
diff --git a/crates/completion/src/completions/keyword.rs b/crates/completion/src/completions/keyword.rs
index 720349b9d..1859dec70 100644
--- a/crates/completion/src/completions/keyword.rs
+++ b/crates/completion/src/completions/keyword.rs
@@ -223,21 +223,21 @@ mod tests {
         check(
             r"m<|>",
             expect![[r#"
-                kw const
-                kw enum
-                kw extern
                 kw fn
+                kw use
                 kw impl
-                kw mod
-                kw pub
-                kw pub(crate)
-                kw static
-                kw struct
                 kw trait
-                kw type
+                kw enum
+                kw struct
                 kw union
+                kw mod
+                kw const
+                kw type
+                kw static
+                kw extern
                 kw unsafe
-                kw use
+                kw pub(crate)
+                kw pub
             "#]],
         );
     }
@@ -247,23 +247,23 @@ mod tests {
         check(
             r"fn quux() { <|> }",
             expect![[r#"
-                kw const
-                kw extern
                 kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw impl
                 kw let
-                kw loop
-                kw match
                 kw mod
-                kw return
-                kw static
-                kw trait
+                kw const
                 kw type
+                kw static
+                kw extern
                 kw unsafe
-                kw use
-                kw while
+                kw return
             "#]],
         );
     }
@@ -273,23 +273,23 @@ mod tests {
         check(
             r"fn quux() { if true { <|> } }",
             expect![[r#"
-                kw const
-                kw extern
                 kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw impl
                 kw let
-                kw loop
-                kw match
                 kw mod
-                kw return
-                kw static
-                kw trait
+                kw const
                 kw type
+                kw static
+                kw extern
                 kw unsafe
-                kw use
-                kw while
+                kw return
             "#]],
         );
     }
@@ -299,25 +299,25 @@ mod tests {
         check(
             r#"fn quux() { if true { () } <|> }"#,
             expect![[r#"
-                kw const
-                kw else
-                kw else if
-                kw extern
                 kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw impl
                 kw let
-                kw loop
-                kw match
+                kw else
+                kw else if
                 kw mod
-                kw return
-                kw static
-                kw trait
+                kw const
                 kw type
+                kw static
+                kw extern
                 kw unsafe
-                kw use
-                kw while
+                kw return
             "#]],
         );
         check_edit(
@@ -336,13 +336,13 @@ fn quux() -> i32 {
 }
 "#,
             expect![[r#"
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw loop
-                kw match
-                kw return
                 kw unsafe
-                kw while
+                kw return
             "#]],
         );
     }
@@ -352,8 +352,8 @@ fn quux() -> i32 {
         check(
             r"trait My { <|> }",
             expect![[r#"
-                kw const
                 kw fn
+                kw const
                 kw type
                 kw unsafe
             "#]],
@@ -365,12 +365,12 @@ fn quux() -> i32 {
         check(
             r"impl My { <|> }",
             expect![[r#"
-                kw const
                 kw fn
-                kw pub
-                kw pub(crate)
+                kw const
                 kw type
                 kw unsafe
+                kw pub(crate)
+                kw pub
             "#]],
         );
     }
@@ -380,25 +380,25 @@ fn quux() -> i32 {
         check(
             r"fn my() { loop { <|> } }",
             expect![[r#"
-                kw break
-                kw const
-                kw continue
-                kw extern
                 kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw impl
                 kw let
-                kw loop
-                kw match
                 kw mod
-                kw return
-                kw static
-                kw trait
+                kw const
                 kw type
+                kw static
+                kw extern
                 kw unsafe
-                kw use
-                kw while
+                kw continue
+                kw break
+                kw return
             "#]],
         );
     }
@@ -409,8 +409,8 @@ fn quux() -> i32 {
             r"unsafe <|>",
             expect![[r#"
                 kw fn
-                kw impl
                 kw trait
+                kw impl
             "#]],
         );
     }
@@ -421,8 +421,8 @@ fn quux() -> i32 {
             r"fn my_fn() { unsafe <|> }",
             expect![[r#"
                 kw fn
-                kw impl
                 kw trait
+                kw impl
             "#]],
         );
     }
@@ -542,12 +542,12 @@ pub mod future {
         check(
             r#"fn main() { let _ = <|> }"#,
             expect![[r#"
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw loop
-                kw match
                 kw return
-                kw while
             "#]],
         )
     }
@@ -562,8 +562,8 @@ struct Foo {
 }
 "#,
             expect![[r#"
-                kw pub
                 kw pub(crate)
+                kw pub
             "#]],
         )
     }
@@ -600,12 +600,12 @@ fn foo() {
 }
 "#,
             expect![[r#"
+                kw match
+                kw while
+                kw loop
                 kw if
                 kw if let
-                kw loop
-                kw match
                 kw return
-                kw while
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/mod_.rs b/crates/completion/src/completions/mod_.rs
index c96f84171..f77864b77 100644
--- a/crates/completion/src/completions/mod_.rs
+++ b/crates/completion/src/completions/mod_.rs
@@ -170,8 +170,8 @@ mod tests {
             fn ignored_bar() {}
         "#,
             expect![[r#"
-                md bar;
                 md foo;
+                md bar;
             "#]],
         );
     }
@@ -207,8 +207,8 @@ mod tests {
             fn ignored_bar() {}
         "#,
             expect![[r#"
-                md bar;
                 md foo;
+                md bar;
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 4f63ff0ef..0c98e4412 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -66,10 +66,10 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                st Bar
                 en E
-                ev X   ()
                 ct Z
+                st Bar
+                ev X   ()
                 md m
             "#]],
         );
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index c8ba63cd3..d6db82a93 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -315,20 +315,20 @@ fn main() {
 }
 "#,
             expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                 sn if    if expr {}
-                sn let   let
-                sn letm  let mut
-                sn match match expr {}
+                sn while while expr {}
                 sn not   !expr
-                sn ok    Ok(expr)
                 sn ref   &expr
                 sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                 sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
@@ -347,18 +347,18 @@ fn main() {
 }
 "#,
             expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                 sn if    if expr {}
-                sn match match expr {}
+                sn while while expr {}
                 sn not   !expr
-                sn ok    Ok(expr)
                 sn ref   &expr
                 sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                 sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
             "#]],
         );
     }
@@ -373,17 +373,17 @@ fn main() {
 }
 "#,
             expect![[r#"
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
                 sn box   Box::new(expr)
-                sn call  function(expr)
+                sn ok    Ok(expr)
+                sn some  Some(expr)
                 sn dbg   dbg!(expr)
                 sn dbgr  dbg!(&expr)
+                sn call  function(expr)
                 sn let   let
                 sn letm  let mut
-                sn match match expr {}
-                sn ok    Ok(expr)
-                sn ref   &expr
-                sn refm  &mut expr
-                sn some  Some(expr)
             "#]],
         )
     }
@@ -398,20 +398,20 @@ fn main() {
 }
 "#,
             expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                 sn if    if expr {}
-                sn let   let
-                sn letm  let mut
-                sn match match expr {}
+                sn while while expr {}
                 sn not   !expr
-                sn ok    Ok(expr)
                 sn ref   &expr
                 sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                 sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
index bc23bea3f..1300f00b2 100644
--- a/crates/completion/src/completions/qualified_path.rs
+++ b/crates/completion/src/completions/qualified_path.rs
@@ -199,22 +199,22 @@ use self::{foo::*, bar<|>};
         check_builtin(
             r#"fn main() { let _: <|> = 92; }"#,
             expect![[r#"
+                bt u32
                 bt bool
-                bt char
+                bt u8
+                bt isize
+                bt u16
+                bt u64
+                bt u128
                 bt f32
-                bt f64
                 bt i128
                 bt i16
-                bt i32
+                bt str
                 bt i64
+                bt char
+                bt f64
+                bt i32
                 bt i8
-                bt isize
-                bt str
-                bt u128
-                bt u16
-                bt u32
-                bt u64
-                bt u8
                 bt usize
             "#]],
         );
@@ -279,8 +279,8 @@ struct Spam;
 use crate::Sp<|>
 "#,
             expect![[r#"
-                st Spam
                 md foo
+                st Spam
             "#]],
         );
     }
@@ -296,8 +296,8 @@ struct Spam;
 use crate::{Sp<|>};
 "#,
             expect![[r#"
-                st Spam
                 md foo
+                st Spam
             "#]],
         );
     }
@@ -330,8 +330,8 @@ enum E { Foo, Bar(i32) }
 fn foo() { let _ = E::<|> }
 "#,
             expect![[r#"
-                ev Bar(…) (i32)
                 ev Foo    ()
+                ev Bar(…) (i32)
             "#]],
         );
     }
@@ -353,10 +353,10 @@ impl S {
 fn foo() { let _ = S::<|> }
 "#,
             expect![[r#"
-                ct C    const C: i32 = 42;
-                ta T    type T = i32;
                 fn a()  fn a()
                 me b(…) fn b(&self)
+                ct C    const C: i32 = 42;
+                ta T    type T = i32;
             "#]],
         );
     }
@@ -381,9 +381,9 @@ mod m {
 fn foo() { let _ = S::<|> }
 "#,
             expect![[r#"
+                fn public_method() pub(crate) fn public_method()
                 ct PUBLIC_CONST    pub(crate) const PUBLIC_CONST: u32 = 1;
                 ta PublicType      pub(crate) type PublicType = u32;
-                fn public_method() pub(crate) fn public_method()
             "#]],
         );
     }
@@ -503,14 +503,14 @@ trait Sub: Super {
 fn foo<T: Sub>() { T::<|> }
 "#,
             expect![[r#"
-                ct C2           const C2: ();
-                ct CONST        const CONST: u8;
                 ta SubTy        type SubTy;
                 ta Ty           type Ty;
-                fn func()       fn func()
-                me method(…)    fn method(&self)
+                ct C2           const C2: ();
                 fn subfunc()    fn subfunc()
                 me submethod(…) fn submethod(&self)
+                ct CONST        const CONST: u8;
+                fn func()       fn func()
+                me method(…)    fn method(&self)
             "#]],
         );
     }
@@ -543,12 +543,12 @@ impl<T> Sub for Wrap<T> {
 }
 "#,
             expect![[r#"
-                ct C2           const C2: () = ();
-                ct CONST        const CONST: u8 = 0;
                 ta SubTy        type SubTy;
                 ta Ty           type Ty;
+                ct CONST        const CONST: u8 = 0;
                 fn func()       fn func()
                 me method(…)    fn method(&self)
+                ct C2           const C2: () = ();
                 fn subfunc()    fn subfunc()
                 me submethod(…) fn submethod(&self)
             "#]],
@@ -567,8 +567,8 @@ impl T { fn bar() {} }
 fn main() { T::<|>; }
 "#,
             expect![[r#"
-                fn bar() fn bar()
                 fn foo() fn foo()
+                fn bar() fn bar()
             "#]],
         );
     }
@@ -583,9 +583,9 @@ macro_rules! foo { () => {} }
 fn main() { let _ = crate::<|> }
         "#,
             expect![[r##"
+                fn main()  fn main()
                 ma foo!(…) #[macro_export]
                 macro_rules! foo
-                fn main()  fn main()
             "##]],
         );
     }
@@ -603,8 +603,8 @@ mod a {
 }
 "#,
             expect![[r#"
-                ct A
                 md b
+                ct A
             "#]],
         );
     }
@@ -628,8 +628,8 @@ mod p {
 "#,
             expect![[r#"
                 ct RIGHT_CONST
-                st RightType
                 fn right_fn()  fn wrong_fn()
+                st RightType
             "#]],
         );
 
@@ -675,8 +675,8 @@ fn main() { m!(self::f<|>); }
 fn foo() {}
 "#,
             expect![[r#"
-                fn foo()  fn foo()
                 fn main() fn main()
+                fn foo()  fn foo()
             "#]],
         );
     }
@@ -747,8 +747,8 @@ fn main() {
 }
 "#,
             expect![[r#"
-                fn foo(…) fn foo(a: i32, b: i32)
                 fn main() fn main()
+                fn foo(…) fn foo(a: i32, b: i32)
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index eaa44c97d..91bf4a8ad 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -94,9 +94,9 @@ fn process(f: S) {
         check_snippet(
             test_code,
             expect![[r#"
-                fd ..Default::default()
                 sn pd
                 sn ppd
+                fd ..Default::default()
             "#]],
         );
     }
@@ -160,8 +160,8 @@ fn process(e: E) {
 }
 "#,
             expect![[r#"
-                fd bar ()
                 fd foo u32
+                fd bar ()
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/snippet.rs b/crates/completion/src/completions/snippet.rs
index 6f0c00078..842590130 100644
--- a/crates/completion/src/completions/snippet.rs
+++ b/crates/completion/src/completions/snippet.rs
@@ -105,9 +105,9 @@ mod tests {
 }
 "#,
             expect![[r#"
-                sn macro_rules
-                sn tfn (Test function)
                 sn tmod (Test module)
+                sn tfn (Test function)
+                sn macro_rules
             "#]],
         )
     }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index e2fe44aff..c4e0d0669 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -266,10 +266,10 @@ impl Test for T {
 }
 "#,
             expect![["
+ta type TestType = \n\
 ct const TEST_CONST: u16 = \n\
 fn fn test()
-ta type TestType = \n\
-            "]],
+"]],
         );
     }
 
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 93869f92e..099ffb4d4 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,7 +1,7 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
 use either::Either;
-use hir::{Adt, ModuleDef, ScopeDef, Type};
+use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
 use ide_db::helpers::insert_use::ImportScope;
 use ide_db::imports_locator;
 use syntax::AstNode;
@@ -146,13 +146,9 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
     .filter(|(mod_path, _)| mod_path.len() > 1)
     .collect::<Vec<_>>();
 
+    let user_input_lowercased = potential_import_name.to_lowercase();
     all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
-        if let Some(name) = mod_path.segments.last().map(|name| name.to_string().to_lowercase()) {
-            if name.contains(&potential_import_name.to_lowercase()) {
-                return 0;
-            }
-        }
-        1
+        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
     });
 
     acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
@@ -165,21 +161,48 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
     Some(())
 }
 
+fn compute_fuzzy_completion_order_key(
+    proposed_mod_path: &ModPath,
+    user_input_lowercased: &str,
+) -> usize {
+    mark::hit!(certain_fuzzy_order_test);
+    let proposed_import_name = match proposed_mod_path.segments.last() {
+        Some(name) => name.to_string().to_lowercase(),
+        None => return usize::MAX,
+    };
+    match proposed_import_name.match_indices(user_input_lowercased).next() {
+        Some((first_matching_index, _)) => first_matching_index,
+        None => usize::MAX,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::{
-        test_utils::{check_edit, check_edit_with_config, completion_list},
+        test_utils::{check_edit, check_edit_with_config, completion_list_with_config},
         CompletionConfig, CompletionKind,
     };
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        check_with_config(CompletionConfig::default(), ra_fixture, expect);
+    }
+
+    fn check_with_config(config: CompletionConfig, ra_fixture: &str, expect: Expect) {
+        let actual = completion_list_with_config(config, ra_fixture, CompletionKind::Reference);
         expect.assert_eq(&actual)
     }
 
+    fn fuzzy_completion_config() -> CompletionConfig {
+        let mut completion_config = CompletionConfig::default();
+        completion_config
+            .active_resolve_capabilities
+            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
+        completion_config
+    }
+
     #[test]
     fn self_fulfilling_completion() {
         mark::check!(self_fulfilling_completion);
@@ -255,9 +278,9 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                 bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
             "#]],
         );
     }
@@ -277,8 +300,8 @@ fn quux() {
 }
 "#,
             expect![[r#"
-                bn a
                 bn b      i32
+                bn a
                 fn quux() fn quux()
             "#]],
         );
@@ -293,8 +316,8 @@ fn quux() {
 }
 "#,
             expect![[r#"
-                fn quux() fn quux()
                 bn x
+                fn quux() fn quux()
             "#]],
         );
     }
@@ -335,9 +358,9 @@ fn main() {
         check(
             r#"struct S<T> { x: <|>}"#,
             expect![[r#"
-                st S<…>
                 tp Self
                 tp T
+                st S<…>
             "#]],
         );
     }
@@ -362,9 +385,9 @@ enum E {}
 fn quux() { <|> }
 "#,
             expect![[r#"
-                en E
                 st S
                 fn quux() fn quux()
+                en E
             "#]],
         );
     }
@@ -416,8 +439,8 @@ mod m {
 }
 "#,
             expect![[r#"
-                st Bar
                 fn quux() fn quux()
+                st Bar
             "#]],
         );
     }
@@ -462,8 +485,8 @@ fn foo() {
         check(
             r#"impl S { fn foo(&self) { <|> } }"#,
             expect![[r#"
-                tp Self
                 bn self &{unknown}
+                tp Self
             "#]],
         );
     }
@@ -482,9 +505,9 @@ use prelude::*;
 mod prelude { struct Option; }
 "#,
             expect![[r#"
-                st Option
                 fn foo()  fn foo()
                 md std
+                st Option
             "#]],
         );
     }
@@ -509,10 +532,10 @@ use prelude::*;
 mod prelude { struct String; }
 "#,
             expect![[r#"
-                st String
-                md core
                 fn foo()  fn foo()
                 md std
+                md core
+                st String
             "#]],
         );
     }
@@ -538,13 +561,13 @@ mod m2 {
 fn main() { let v = <|> }
 "#,
             expect![[r##"
-                ma bar!(…) macro_rules! bar
+                md m1
                 ma baz!(…) #[macro_export]
                 macro_rules! baz
-                ma foo!(…) macro_rules! foo
-                md m1
-                md m2
                 fn main()  fn main()
+                md m2
+                ma bar!(…) macro_rules! bar
+                ma foo!(…) macro_rules! foo
             "##]],
         );
     }
@@ -557,8 +580,8 @@ macro_rules! foo { () => {} }
 fn foo() { <|> }
 "#,
             expect![[r#"
-                ma foo!(…) macro_rules! foo
                 fn foo()   fn foo()
+                ma foo!(…) macro_rules! foo
             "#]],
         );
     }
@@ -571,8 +594,8 @@ macro_rules! foo { () => {} }
 fn main() { let x: <|> }
 "#,
             expect![[r#"
-                ma foo!(…) macro_rules! foo
                 fn main()  fn main()
+                ma foo!(…) macro_rules! foo
             "#]],
         );
     }
@@ -585,8 +608,8 @@ macro_rules! foo { () => {} }
 fn main() { <|> }
 "#,
             expect![[r#"
-                ma foo!(…) macro_rules! foo
                 fn main()  fn main()
+                ma foo!(…) macro_rules! foo
             "#]],
         );
     }
@@ -618,10 +641,10 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                 bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
             "#]],
         );
     }
@@ -637,10 +660,10 @@ fn quux(x: i32) {
 }
 ",
             expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                 bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
             "#]],
         );
     }
@@ -656,10 +679,10 @@ fn quux(x: i32) {
 }
 "#,
             expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                 bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
             "#]],
         );
     }
@@ -673,8 +696,8 @@ use spam::Quux;
 fn main() { <|> }
 "#,
             expect![[r#"
-                ?? Quux
                 fn main() fn main()
+                ?? Quux
             "#]],
         );
     }
@@ -690,10 +713,10 @@ fn main() {
 }
 "#,
             expect![[r#"
-                en Foo
                 ev Foo::Bar  ()
                 ev Foo::Baz  ()
                 ev Foo::Quux ()
+                en Foo
             "#]],
         )
     }
@@ -710,10 +733,10 @@ fn main() {
 }
 "#,
             expect![[r#"
-                en Foo
                 ev Foo::Bar  ()
                 ev Foo::Baz  ()
                 ev Foo::Quux ()
+                en Foo
             "#]],
         )
     }
@@ -726,10 +749,10 @@ enum Foo { Bar, Baz, Quux }
 fn main() { let foo: Foo = Q<|> }
 "#,
             expect![[r#"
-                en Foo
                 ev Foo::Bar  ()
                 ev Foo::Baz  ()
                 ev Foo::Quux ()
+                en Foo
                 fn main()    fn main()
             "#]],
         )
@@ -743,9 +766,9 @@ mod m { pub enum E { V } }
 fn f() -> m::E { V<|> }
 "#,
             expect![[r#"
-                fn f()     fn f() -> m::E
-                md m
                 ev m::E::V ()
+                md m
+                fn f()     fn f() -> m::E
             "#]],
         )
     }
@@ -772,22 +795,17 @@ struct MyStruct {}
 impl My<|>
 "#,
             expect![[r#"
-                st MyStruct
-                tt MyTrait
                 tp Self
+                tt MyTrait
+                st MyStruct
             "#]],
         )
     }
 
     #[test]
     fn function_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
-
         check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
             "stdin",
             r#"
 //- /lib.rs crate:dep
@@ -812,13 +830,8 @@ fn main() {
 
     #[test]
     fn macro_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
-
         check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
             "macro_with_curlies!",
             r#"
 //- /lib.rs crate:dep
@@ -845,13 +858,8 @@ fn main() {
 
     #[test]
     fn struct_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
-
         check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
             "ThirdStruct",
             r#"
 //- /lib.rs crate:dep
@@ -877,4 +885,44 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn fuzzy_completions_come_in_specific_order() {
+        mark::check!(certain_fuzzy_order_test);
+        check_with_config(
+            fuzzy_completion_config(),
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    // already imported, omitted
+    pub struct SecondStruct;
+    // does not contain all letters from the query, omitted
+    pub struct UnrelatedOne;
+    // contains all letters from the query, but not in sequence, displayed last
+    pub struct ThiiiiiirdStruct;
+    // contains all letters from the query, but not in the beginning, displayed second
+    pub struct AfterThirdStruct;
+    // contains all letters from the query in the begginning, displayed first
+    pub struct ThirdStruct;
+}
+
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+
+fn main() {
+    hir<|>
+}
+"#,
+            expect![[r#"
+                fn main()           fn main()
+                st SecondStruct
+                st FirstStruct
+                md dep
+                st dep::some_module::ThirdStruct
+                st dep::some_module::AfterThirdStruct
+                st dep::some_module::ThiiiiiirdStruct
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index db896b2df..eb0c16f52 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -47,9 +47,8 @@ pub(crate) fn completion_list_with_config(
     code: &str,
     kind: CompletionKind,
 ) -> String {
-    let mut kind_completions: Vec<CompletionItem> =
+    let kind_completions: Vec<CompletionItem> =
         get_all_items(config, code).into_iter().filter(|c| c.completion_kind == kind).collect();
-    kind_completions.sort_by_key(|c| c.label().to_owned());
     let label_width = kind_completions
         .iter()
         .map(|it| monospace_width(it.label()))
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 9cd0b72aa..042e119b1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -5,20 +5,21 @@ use std::{ops, sync::Arc};
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, AstId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
 use itertools::Itertools;
 use mbe::ast_to_token_tree;
 use syntax::{
     ast::{self, AstNode, AttrsOwner},
     match_ast, AstToken, SmolStr, SyntaxNode,
 };
+use test_utils::mark;
 use tt::Subtree;
 
 use crate::{
     db::DefDatabase,
     item_tree::{ItemTreeId, ItemTreeNode},
     nameres::ModuleSource,
-    path::ModPath,
+    path::{ModPath, PathKind},
     src::HasChildSource,
     AdtId, AttrDefId, Lookup,
 };
@@ -41,7 +42,7 @@ impl From<Documentation> for String {
 
 /// Syntactical attributes, without filtering of `cfg_attr`s.
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct RawAttrs {
+pub(crate) struct RawAttrs {
     entries: Option<Arc<[Attr]>>,
 }
 
@@ -71,35 +72,34 @@ impl ops::Deref for Attrs {
 }
 
 impl RawAttrs {
-    pub const EMPTY: Self = Self { entries: None };
+    pub(crate) const EMPTY: Self = Self { entries: None };
 
     pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Self {
-        let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
-            .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
-
-        let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
-        let attrs = outer_attrs
-            .chain(inner_attrs.into_iter().flatten())
-            .map(|attr| (attr.syntax().text_range().start(), Attr::from_src(attr, hygiene)));
-
-        let outer_docs =
-            ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
-        let docs = outer_docs.chain(inner_docs.into_iter().flatten()).map(|docs_text| {
-            (
-                docs_text.syntax().text_range().start(),
-                docs_text.doc_comment().map(|doc| Attr {
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                    path: ModPath::from(hir_expand::name!(doc)),
-                }),
-            )
-        });
-        // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-        let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+        let attrs: Vec<_> = collect_attrs(owner).collect();
         let entries = if attrs.is_empty() {
             // Avoid heap allocation
             None
         } else {
-            Some(attrs.into_iter().flat_map(|(_, attr)| attr).collect())
+            Some(
+                attrs
+                    .into_iter()
+                    .enumerate()
+                    .flat_map(|(i, attr)| match attr {
+                        Either::Left(attr) => Attr::from_src(attr, hygiene).map(|attr| (i, attr)),
+                        Either::Right(comment) => comment.doc_comment().map(|doc| {
+                            (
+                                i,
+                                Attr {
+                                    index: 0,
+                                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                                    path: ModPath::from(hir_expand::name!(doc)),
+                                },
+                            )
+                        }),
+                    })
+                    .map(|(i, attr)| Attr { index: i as u32, ..attr })
+                    .collect(),
+            )
         };
         Self { entries }
     }
@@ -122,9 +122,69 @@ impl RawAttrs {
     }
 
     /// Processes `cfg_attr`s, returning the resulting semantic `Attrs`.
-    pub(crate) fn filter(self, _db: &dyn DefDatabase, _krate: CrateId) -> Attrs {
-        // FIXME actually implement this
-        Attrs(self)
+    pub(crate) fn filter(self, db: &dyn DefDatabase, krate: CrateId) -> Attrs {
+        let has_cfg_attrs = self.iter().any(|attr| {
+            attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr])
+        });
+        if !has_cfg_attrs {
+            return Attrs(self);
+        }
+
+        let crate_graph = db.crate_graph();
+        let new_attrs = self
+            .iter()
+            .filter_map(|attr| {
+                let attr = attr.clone();
+                let is_cfg_attr =
+                    attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr]);
+                if !is_cfg_attr {
+                    return Some(attr);
+                }
+
+                let subtree = match &attr.input {
+                    Some(AttrInput::TokenTree(it)) => it,
+                    _ => return Some(attr),
+                };
+
+                // Input subtree is: `(cfg, attr)`
+                // Split it up into a `cfg` and an `attr` subtree.
+                // FIXME: There should be a common API for this.
+                let mut saw_comma = false;
+                let (mut cfg, attr): (Vec<_>, Vec<_>) =
+                    subtree.clone().token_trees.into_iter().partition(|tree| {
+                        if saw_comma {
+                            return false;
+                        }
+
+                        match tree {
+                            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
+                                saw_comma = true;
+                            }
+                            _ => {}
+                        }
+
+                        true
+                    });
+                cfg.pop(); // `,` ends up in here
+
+                let attr = Subtree { delimiter: None, token_trees: attr };
+                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg };
+                let cfg = CfgExpr::parse(&cfg);
+
+                let cfg_options = &crate_graph[krate].cfg_options;
+                if cfg_options.check(&cfg) == Some(false) {
+                    None
+                } else {
+                    mark::hit!(cfg_attr_active);
+
+                    let attr = ast::Attr::parse(&format!("#[{}]", attr)).ok()?;
+                    let hygiene = Hygiene::new_unhygienic(); // FIXME
+                    Attr::from_src(attr, &hygiene)
+                }
+            })
+            .collect();
+
+        Attrs(RawAttrs { entries: Some(new_attrs) })
     }
 }
 
@@ -180,24 +240,11 @@ impl Attrs {
         raw_attrs.filter(db, def.krate(db))
     }
 
-    pub fn merge(&self, other: Attrs) -> Attrs {
-        match (&self.0.entries, &other.0.entries) {
-            (None, None) => Attrs::EMPTY,
-            (Some(entries), None) | (None, Some(entries)) => {
-                Attrs(RawAttrs { entries: Some(entries.clone()) })
-            }
-            (Some(a), Some(b)) => {
-                Attrs(RawAttrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) })
-            }
-        }
-    }
-
     pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
         AttrQuery { attrs: self, key }
     }
 
     pub fn cfg(&self) -> Option<CfgExpr> {
-        // FIXME: handle cfg_attr :-)
         let mut cfgs = self.by_key("cfg").tt_values().map(CfgExpr::parse).collect::<Vec<_>>();
         match cfgs.len() {
             0 => None,
@@ -268,6 +315,7 @@ fn inner_attributes(
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
+    index: u32,
     pub(crate) path: ModPath,
     pub(crate) input: Option<AttrInput>,
 }
@@ -294,7 +342,59 @@ impl Attr {
         } else {
             None
         };
-        Some(Attr { path, input })
+        Some(Attr { index: 0, path, input })
+    }
+
+    /// Maps this lowered `Attr` back to its original syntax node.
+    ///
+    /// `owner` must be the original owner of the attribute.
+    ///
+    /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of
+    /// the attribute represented by `Attr`.
+    pub fn to_src(&self, owner: &dyn AttrsOwner) -> Either<ast::Attr, ast::Comment> {
+        collect_attrs(owner).nth(self.index as usize).unwrap_or_else(|| {
+            panic!("cannot find `Attr` at index {} in {}", self.index, owner.syntax())
+        })
+    }
+
+    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
+    /// to derive macros.
+    ///
+    /// Returns `None` when the attribute is not a well-formed `#[derive]` attribute.
+    pub(crate) fn parse_derive(&self) -> Option<impl Iterator<Item = ModPath>> {
+        if self.path.as_ident() != Some(&hir_expand::name![derive]) {
+            return None;
+        }
+
+        match &self.input {
+            Some(AttrInput::TokenTree(args)) => {
+                let mut counter = 0;
+                let paths = args
+                    .token_trees
+                    .iter()
+                    .group_by(move |tt| {
+                        match tt {
+                            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
+                                counter += 1;
+                            }
+                            _ => {}
+                        }
+                        counter
+                    })
+                    .into_iter()
+                    .map(|(_, tts)| {
+                        let segments = tts.filter_map(|tt| match tt {
+                            tt::TokenTree::Leaf(tt::Leaf::Ident(id)) => Some(id.as_name()),
+                            _ => None,
+                        });
+                        ModPath::from_segments(PathKind::Plain, segments)
+                    })
+                    .collect::<Vec<_>>();
+
+                Some(paths.into_iter())
+            }
+            _ => None,
+        }
     }
 }
 
@@ -323,7 +423,7 @@ impl<'a> AttrQuery<'a> {
         self.attrs().next().is_some()
     }
 
-    fn attrs(self) -> impl Iterator<Item = &'a Attr> {
+    pub(crate) fn attrs(self) -> impl Iterator<Item = &'a Attr> {
         let key = self.key;
         self.attrs
             .iter()
@@ -344,3 +444,23 @@ fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase
     let mod_item = N::id_to_mod_item(id.value);
     tree.raw_attrs(mod_item.into()).clone()
 }
+
+fn collect_attrs(owner: &dyn AttrsOwner) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
+    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
+        .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
+
+    let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
+    let attrs = outer_attrs
+        .chain(inner_attrs.into_iter().flatten())
+        .map(|attr| (attr.syntax().text_range().start(), Either::Left(attr)));
+
+    let outer_docs =
+        ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
+    let docs = outer_docs
+        .chain(inner_docs.into_iter().flatten())
+        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
+    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
+    let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+
+    attrs.into_iter().map(|(_, attr)| attr)
+}
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 5eb7cae7f..100dbf5d6 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -12,7 +12,7 @@ use std::{
 };
 
 use arena::{Arena, Idx, RawId};
-use ast::{AstNode, AttrsOwner, NameOwner, StructKind};
+use ast::{AstNode, NameOwner, StructKind};
 use base_db::CrateId;
 use either::Either;
 use hir_expand::{
@@ -495,7 +495,6 @@ pub struct Import {
     pub alias: Option<ImportAlias>,
     pub visibility: RawVisibilityId,
     pub is_glob: bool,
-    pub is_prelude: bool,
     /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
     /// `Import`s can map to the same `use` item.
     pub ast_id: FileAstId<ast::Use>,
@@ -511,8 +510,6 @@ pub struct ExternCrate {
     pub name: Name,
     pub alias: Option<ImportAlias>,
     pub visibility: RawVisibilityId,
-    /// Whether this is a `#[macro_use] extern crate ...`.
-    pub is_macro_use: bool,
     pub ast_id: FileAstId<ast::ExternCrate>,
 }
 
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index c8f090c22..3b206ef85 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -485,8 +485,6 @@ impl Ctx {
     }
 
     fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> {
-        // FIXME: cfg_attr
-        let is_prelude = use_item.has_atom_attr("prelude_import");
         let visibility = self.lower_visibility(use_item);
         let ast_id = self.source_ast_id_map.ast_id(use_item);
 
@@ -502,7 +500,6 @@ impl Ctx {
                     alias,
                     visibility,
                     is_glob,
-                    is_prelude,
                     ast_id,
                     index: imports.len(),
                 })));
@@ -522,10 +519,8 @@ impl Ctx {
         });
         let visibility = self.lower_visibility(extern_crate);
         let ast_id = self.source_ast_id_map.ast_id(extern_crate);
-        // FIXME: cfg_attr
-        let is_macro_use = extern_crate.has_atom_attr("macro_use");
 
-        let res = ExternCrate { name, alias, visibility, is_macro_use, ast_id };
+        let res = ExternCrate { name, alias, visibility, ast_id };
         Some(id(self.data().extern_crates.alloc(res)))
     }
 
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index b114a6fe4..a636ec77d 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -136,23 +136,35 @@ struct Import {
 }
 
 impl Import {
-    fn from_use(tree: &ItemTree, id: ItemTreeId<item_tree::Import>) -> Self {
+    fn from_use(
+        db: &dyn DefDatabase,
+        krate: CrateId,
+        tree: &ItemTree,
+        id: ItemTreeId<item_tree::Import>,
+    ) -> Self {
         let it = &tree[id.value];
+        let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
         let visibility = &tree[it.visibility];
         Self {
             path: it.path.clone(),
             alias: it.alias.clone(),
             visibility: visibility.clone(),
             is_glob: it.is_glob,
-            is_prelude: it.is_prelude,
+            is_prelude: attrs.by_key("prelude_import").exists(),
             is_extern_crate: false,
             is_macro_use: false,
             source: ImportSource::Import(id),
         }
     }
 
-    fn from_extern_crate(tree: &ItemTree, id: ItemTreeId<item_tree::ExternCrate>) -> Self {
+    fn from_extern_crate(
+        db: &dyn DefDatabase,
+        krate: CrateId,
+        tree: &ItemTree,
+        id: ItemTreeId<item_tree::ExternCrate>,
+    ) -> Self {
         let it = &tree[id.value];
+        let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
         let visibility = &tree[it.visibility];
         Self {
             path: ModPath::from_segments(PathKind::Plain, iter::once(it.name.clone())),
@@ -161,7 +173,7 @@ impl Import {
             is_glob: false,
             is_prelude: false,
             is_extern_crate: true,
-            is_macro_use: it.is_macro_use,
+            is_macro_use: attrs.by_key("macro_use").exists(),
             source: ImportSource::ExternCrate(id),
         }
     }
@@ -930,7 +942,12 @@ impl ModCollector<'_, '_> {
             if attrs.cfg().map_or(true, |cfg| self.is_cfg_enabled(&cfg)) {
                 if let ModItem::ExternCrate(id) = item {
                     let import = self.item_tree[*id].clone();
-                    if import.is_macro_use {
+                    let attrs = self.item_tree.attrs(
+                        self.def_collector.db,
+                        krate,
+                        ModItem::from(*id).into(),
+                    );
+                    if attrs.by_key("macro_use").exists() {
                         self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
                     }
                 }
@@ -956,6 +973,8 @@ impl ModCollector<'_, '_> {
                     self.def_collector.unresolved_imports.push(ImportDirective {
                         module_id: self.module_id,
                         import: Import::from_use(
+                            self.def_collector.db,
+                            krate,
                             &self.item_tree,
                             InFile::new(self.file_id, import_id),
                         ),
@@ -966,6 +985,8 @@ impl ModCollector<'_, '_> {
                     self.def_collector.unresolved_imports.push(ImportDirective {
                         module_id: self.module_id,
                         import: Import::from_extern_crate(
+                            self.def_collector.db,
+                            krate,
                             &self.item_tree,
                             InFile::new(self.file_id, import_id),
                         ),
@@ -1268,20 +1289,20 @@ impl ModCollector<'_, '_> {
     }
 
     fn collect_derives(&mut self, attrs: &Attrs, ast_id: FileAstId<ast::Item>) {
-        for derive_subtree in attrs.by_key("derive").tt_values() {
-            // for #[derive(Copy, Clone)], `derive_subtree` is the `(Copy, Clone)` subtree
-            for tt in &derive_subtree.token_trees {
-                let ident = match &tt {
-                    tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => ident,
-                    tt::TokenTree::Leaf(tt::Leaf::Punct(_)) => continue, // , is ok
-                    _ => continue, // anything else would be an error (which we currently ignore)
-                };
-                let path = ModPath::from_tt_ident(ident);
-
-                let ast_id = AstIdWithPath::new(self.file_id, ast_id, path);
-                self.def_collector
-                    .unexpanded_attribute_macros
-                    .push(DeriveDirective { module_id: self.module_id, ast_id });
+        for derive in attrs.by_key("derive").attrs() {
+            match derive.parse_derive() {
+                Some(derive_macros) => {
+                    for path in derive_macros {
+                        let ast_id = AstIdWithPath::new(self.file_id, ast_id, path);
+                        self.def_collector
+                            .unexpanded_attribute_macros
+                            .push(DeriveDirective { module_id: self.module_id, ast_id });
+                    }
+                }
+                None => {
+                    // FIXME: diagnose
+                    log::debug!("malformed derive: {:?}", derive);
+                }
             }
         }
     }
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index a4d1fb8f3..c459fa66d 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -13,8 +13,8 @@ use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
-fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
-    let db = TestDB::with_files(fixture);
+fn compute_crate_def_map(ra_fixture: &str) -> Arc<CrateDefMap> {
+    let db = TestDB::with_files(ra_fixture);
     let krate = db.crate_graph().iter().next().unwrap();
     db.crate_def_map(krate)
 }
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index 1a7b98831..58d69d3c6 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -1,4 +1,5 @@
 use base_db::fixture::WithFixture;
+use test_utils::mark;
 
 use crate::test_db::TestDB;
 
@@ -119,3 +120,20 @@ fn inactive_item() {
         "#,
     );
 }
+
+/// Tests that `cfg` attributes behind `cfg_attr` is handled properly.
+#[test]
+fn inactive_via_cfg_attr() {
+    mark::check!(cfg_attr_active);
+    check_diagnostics(
+        r#"
+        //- /lib.rs
+          #[cfg_attr(not(never), cfg(no))] fn f() {}
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+
+          #[cfg_attr(not(never), cfg(not(no)))] fn f() {}
+
+          #[cfg_attr(never, cfg(no))] fn g() {}
+        "#,
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index 6fe2ee78a..f9bf5bc72 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -632,11 +632,11 @@ pub struct bar;
 #[test]
 fn expand_derive() {
     let map = compute_crate_def_map(
-        "
+        r#"
         //- /main.rs crate:main deps:core
-        use core::*;
+        use core::Copy;
 
-        #[derive(Copy, Clone)]
+        #[derive(Copy, core::Clone)]
         struct Foo;
 
         //- /core.rs crate:core
@@ -645,7 +645,7 @@ fn expand_derive() {
 
         #[rustc_builtin_macro]
         pub macro Clone {}
-        ",
+        "#,
     );
     assert_eq!(map.modules[map.root].scope.impls().len(), 2);
 }
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 00a69a8a6..e2bf85bbc 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -9,11 +9,8 @@ use std::{
 
 use crate::{body::LowerCtx, type_ref::LifetimeRef};
 use base_db::CrateId;
-use hir_expand::{
-    hygiene::Hygiene,
-    name::{AsName, Name},
-};
-use syntax::ast::{self};
+use hir_expand::{hygiene::Hygiene, name::Name};
+use syntax::ast;
 
 use crate::{
     type_ref::{TypeBound, TypeRef},
@@ -56,11 +53,6 @@ impl ModPath {
         ModPath { kind, segments }
     }
 
-    /// Converts an `tt::Ident` into a single-identifier `Path`.
-    pub(crate) fn from_tt_ident(ident: &tt::Ident) -> ModPath {
-        ident.as_name().into()
-    }
-
     /// Calls `cb` with all paths, represented by this use item.
     pub(crate) fn expand_use_item(
         item_src: InFile<ast::Use>,
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 7fb4caea3..2f44876a8 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -152,7 +152,9 @@ pub mod known {
         str,
         // Special names
         macro_rules,
+        derive,
         doc,
+        cfg_attr,
         // Components of known path (value or mod name)
         std,
         core,
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index 8ad50a2ee..60e0cd4ad 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -181,8 +181,8 @@ fn caller() {
     call<|>ee();
 }
 "#,
-            "callee FN FileId(0) 0..14 3..9",
-            &["caller FN FileId(0) 15..44 18..24 : [33..39]"],
+            "callee Function FileId(0) 0..14 3..9",
+            &["caller Function FileId(0) 15..44 18..24 : [33..39]"],
             &[],
         );
     }
@@ -197,8 +197,8 @@ fn caller() {
     callee();
 }
 "#,
-            "callee FN FileId(0) 0..14 3..9",
-            &["caller FN FileId(0) 15..44 18..24 : [33..39]"],
+            "callee Function FileId(0) 0..14 3..9",
+            &["caller Function FileId(0) 15..44 18..24 : [33..39]"],
             &[],
         );
     }
@@ -214,8 +214,8 @@ fn caller() {
     callee();
 }
 "#,
-            "callee FN FileId(0) 0..14 3..9",
-            &["caller FN FileId(0) 15..58 18..24 : [33..39, 47..53]"],
+            "callee Function FileId(0) 0..14 3..9",
+            &["caller Function FileId(0) 15..58 18..24 : [33..39, 47..53]"],
             &[],
         );
     }
@@ -234,10 +234,10 @@ fn caller2() {
     callee();
 }
 "#,
-            "callee FN FileId(0) 0..14 3..9",
+            "callee Function FileId(0) 0..14 3..9",
             &[
-                "caller1 FN FileId(0) 15..45 18..25 : [34..40]",
-                "caller2 FN FileId(0) 47..77 50..57 : [66..72]",
+                "caller1 Function FileId(0) 15..45 18..25 : [34..40]",
+                "caller2 Function FileId(0) 47..77 50..57 : [66..72]",
             ],
             &[],
         );
@@ -263,10 +263,10 @@ mod tests {
     }
 }
 "#,
-            "callee FN FileId(0) 0..14 3..9",
+            "callee Function FileId(0) 0..14 3..9",
             &[
-                "caller1 FN FileId(0) 15..45 18..25 : [34..40]",
-                "test_caller FN FileId(0) 95..149 110..121 : [134..140]",
+                "caller1 Function FileId(0) 15..45 18..25 : [34..40]",
+                "test_caller Function FileId(0) 95..149 110..121 : [134..140]",
             ],
             &[],
         );
@@ -287,8 +287,8 @@ fn caller() {
 //- /foo/mod.rs
 pub fn callee() {}
 "#,
-            "callee FN FileId(1) 0..18 7..13",
-            &["caller FN FileId(0) 27..56 30..36 : [45..51]"],
+            "callee Function FileId(1) 0..18 7..13",
+            &["caller Function FileId(0) 27..56 30..36 : [45..51]"],
             &[],
         );
     }
@@ -304,9 +304,9 @@ fn call<|>er() {
     callee();
 }
 "#,
-            "caller FN FileId(0) 15..58 18..24",
+            "caller Function FileId(0) 15..58 18..24",
             &[],
-            &["callee FN FileId(0) 0..14 3..9 : [33..39, 47..53]"],
+            &["callee Function FileId(0) 0..14 3..9 : [33..39, 47..53]"],
         );
     }
 
@@ -325,9 +325,9 @@ fn call<|>er() {
 //- /foo/mod.rs
 pub fn callee() {}
 "#,
-            "caller FN FileId(0) 27..56 30..36",
+            "caller Function FileId(0) 27..56 30..36",
             &[],
-            &["callee FN FileId(1) 0..18 7..13 : [45..51]"],
+            &["callee Function FileId(1) 0..18 7..13 : [45..51]"],
         );
     }
 
@@ -348,9 +348,9 @@ fn caller3() {
 
 }
 "#,
-            "caller2 FN FileId(0) 33..64 36..43",
-            &["caller1 FN FileId(0) 0..31 3..10 : [19..26]"],
-            &["caller3 FN FileId(0) 66..83 69..76 : [52..59]"],
+            "caller2 Function FileId(0) 33..64 36..43",
+            &["caller1 Function FileId(0) 0..31 3..10 : [19..26]"],
+            &["caller3 Function FileId(0) 66..83 69..76 : [52..59]"],
         );
     }
 
@@ -368,9 +368,9 @@ fn main() {
     a<|>()
 }
 "#,
-            "a FN FileId(0) 0..18 3..4",
-            &["main FN FileId(0) 31..52 34..38 : [47..48]"],
-            &["b FN FileId(0) 20..29 23..24 : [13..14]"],
+            "a Function FileId(0) 0..18 3..4",
+            &["main Function FileId(0) 31..52 34..38 : [47..48]"],
+            &["b Function FileId(0) 20..29 23..24 : [13..14]"],
         );
 
         check_hierarchy(
@@ -385,8 +385,8 @@ fn main() {
     a()
 }
 "#,
-            "b FN FileId(0) 20..29 23..24",
-            &["a FN FileId(0) 0..18 3..4 : [13..14]"],
+            "b Function FileId(0) 20..29 23..24",
+            &["a Function FileId(0) 0..18 3..4 : [13..14]"],
             &[],
         );
     }
diff --git a/crates/ide/src/display.rs b/crates/ide/src/display.rs
index 0650915c5..bae9e40df 100644
--- a/crates/ide/src/display.rs
+++ b/crates/ide/src/display.rs
@@ -1,10 +1,9 @@
 //! This module contains utilities for turning SyntaxNodes and HIR types
 //! into types that may be used to render in a UI.
 
-mod navigation_target;
+pub(crate) mod navigation_target;
 mod short_label;
 
-pub use navigation_target::NavigationTarget;
 pub(crate) use navigation_target::{ToNav, TryToNav};
 pub(crate) use short_label::ShortLabel;
 
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 48acb8c93..7d0514105 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -1,26 +1,51 @@
 //! FIXME: write short doc here
 
+use std::fmt;
+
 use either::Either;
 use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, ModuleSource};
-use ide_db::base_db::{FileId, SourceDatabase};
+use ide_db::{
+    base_db::{FileId, SourceDatabase},
+    symbol_index::FileSymbolKind,
+};
 use ide_db::{defs::Definition, RootDatabase};
 use syntax::{
     ast::{self, NameOwner},
-    match_ast, AstNode, SmolStr,
-    SyntaxKind::{self, IDENT_PAT, LIFETIME_PARAM, TYPE_PARAM},
-    TextRange,
+    match_ast, AstNode, SmolStr, TextRange,
 };
 
 use crate::FileSymbol;
 
 use super::short_label::ShortLabel;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SymbolKind {
+    Module,
+    Impl,
+    Field,
+    TypeParam,
+    LifetimeParam,
+    ValueParam,
+    SelfParam,
+    Local,
+    Function,
+    Const,
+    Static,
+    Struct,
+    Enum,
+    Variant,
+    Union,
+    TypeAlias,
+    Trait,
+    Macro,
+}
+
 /// `NavigationTarget` represents and element in the editor's UI which you can
 /// click on to navigate to a particular piece of code.
 ///
 /// Typically, a `NavigationTarget` corresponds to some element in the source
 /// code, like a function or a struct, but this is not strictly required.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
     pub file_id: FileId,
     /// Range which encompasses the whole element.
@@ -40,12 +65,30 @@ pub struct NavigationTarget {
     /// Clients should place the cursor on this range when navigating to this target.
     pub focus_range: Option<TextRange>,
     pub name: SmolStr,
-    pub kind: SyntaxKind,
+    pub kind: Option<SymbolKind>,
     pub container_name: Option<SmolStr>,
     pub description: Option<String>,
     pub docs: Option<Documentation>,
 }
 
+impl fmt::Debug for NavigationTarget {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut f = f.debug_struct("NavigationTarget");
+        macro_rules! opt {
+            ($($name:ident)*) => {$(
+                if let Some(it) = &self.$name {
+                    f.field(stringify!($name), it);
+                }
+            )*}
+        }
+        f.field("file_id", &self.file_id).field("full_range", &self.full_range);
+        opt!(focus_range);
+        f.field("name", &self.name);
+        opt!(kind container_name description docs);
+        f.finish()
+    }
+}
+
 pub(crate) trait ToNav {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget;
 }
@@ -69,7 +112,7 @@ impl NavigationTarget {
                 name,
                 None,
                 frange.range,
-                src.value.syntax().kind(),
+                SymbolKind::Module,
             );
             res.docs = module.attrs(db).docs();
             res.description = src.value.short_label();
@@ -86,8 +129,13 @@ impl NavigationTarget {
 
     #[cfg(test)]
     pub(crate) fn debug_render(&self) -> String {
-        let mut buf =
-            format!("{} {:?} {:?} {:?}", self.name, self.kind, self.file_id, self.full_range);
+        let mut buf = format!(
+            "{} {:?} {:?} {:?}",
+            self.name,
+            self.kind.unwrap(),
+            self.file_id,
+            self.full_range
+        );
         if let Some(focus_range) = self.focus_range {
             buf.push_str(&format!(" {:?}", focus_range))
         }
@@ -101,6 +149,7 @@ impl NavigationTarget {
     pub(crate) fn from_named(
         db: &RootDatabase,
         node: InFile<&dyn ast::NameOwner>,
+        kind: SymbolKind,
     ) -> NavigationTarget {
         let name =
             node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
@@ -108,13 +157,7 @@ impl NavigationTarget {
             node.value.name().map(|it| node.with_value(it.syntax()).original_file_range(db).range);
         let frange = node.map(|it| it.syntax()).original_file_range(db);
 
-        NavigationTarget::from_syntax(
-            frange.file_id,
-            name,
-            focus_range,
-            frange.range,
-            node.value.syntax().kind(),
-        )
+        NavigationTarget::from_syntax(frange.file_id, name, focus_range, frange.range, kind)
     }
 
     fn from_syntax(
@@ -122,12 +165,12 @@ impl NavigationTarget {
         name: SmolStr,
         focus_range: Option<TextRange>,
         full_range: TextRange,
-        kind: SyntaxKind,
+        kind: SymbolKind,
     ) -> NavigationTarget {
         NavigationTarget {
             file_id,
             name,
-            kind,
+            kind: Some(kind),
             full_range,
             focus_range,
             container_name: None,
@@ -142,7 +185,17 @@ impl ToNav for FileSymbol {
         NavigationTarget {
             file_id: self.file_id,
             name: self.name.clone(),
-            kind: self.kind,
+            kind: Some(match self.kind {
+                FileSymbolKind::Function => SymbolKind::Function,
+                FileSymbolKind::Struct => SymbolKind::Struct,
+                FileSymbolKind::Enum => SymbolKind::Enum,
+                FileSymbolKind::Trait => SymbolKind::Trait,
+                FileSymbolKind::Module => SymbolKind::Module,
+                FileSymbolKind::TypeAlias => SymbolKind::TypeAlias,
+                FileSymbolKind::Const => SymbolKind::Const,
+                FileSymbolKind::Static => SymbolKind::Static,
+                FileSymbolKind::Macro => SymbolKind::Macro,
+            }),
             full_range: self.range,
             focus_range: self.name_range,
             container_name: self.container_name.clone(),
@@ -191,16 +244,36 @@ impl TryToNav for hir::ModuleDef {
     }
 }
 
-pub(crate) trait ToNavFromAst {}
-impl ToNavFromAst for hir::Function {}
-impl ToNavFromAst for hir::Const {}
-impl ToNavFromAst for hir::Static {}
-impl ToNavFromAst for hir::Struct {}
-impl ToNavFromAst for hir::Enum {}
-impl ToNavFromAst for hir::EnumVariant {}
-impl ToNavFromAst for hir::Union {}
-impl ToNavFromAst for hir::TypeAlias {}
-impl ToNavFromAst for hir::Trait {}
+pub(crate) trait ToNavFromAst {
+    const KIND: SymbolKind;
+}
+impl ToNavFromAst for hir::Function {
+    const KIND: SymbolKind = SymbolKind::Function;
+}
+impl ToNavFromAst for hir::Const {
+    const KIND: SymbolKind = SymbolKind::Const;
+}
+impl ToNavFromAst for hir::Static {
+    const KIND: SymbolKind = SymbolKind::Static;
+}
+impl ToNavFromAst for hir::Struct {
+    const KIND: SymbolKind = SymbolKind::Struct;
+}
+impl ToNavFromAst for hir::Enum {
+    const KIND: SymbolKind = SymbolKind::Enum;
+}
+impl ToNavFromAst for hir::EnumVariant {
+    const KIND: SymbolKind = SymbolKind::Variant;
+}
+impl ToNavFromAst for hir::Union {
+    const KIND: SymbolKind = SymbolKind::Union;
+}
+impl ToNavFromAst for hir::TypeAlias {
+    const KIND: SymbolKind = SymbolKind::TypeAlias;
+}
+impl ToNavFromAst for hir::Trait {
+    const KIND: SymbolKind = SymbolKind::Trait;
+}
 
 impl<D> ToNav for D
 where
@@ -209,8 +282,11 @@ where
 {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let mut res =
-            NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
+        let mut res = NavigationTarget::from_named(
+            db,
+            src.as_ref().map(|it| it as &dyn ast::NameOwner),
+            D::KIND,
+        );
         res.docs = self.docs(db);
         res.description = src.value.short_label();
         res
@@ -228,7 +304,7 @@ impl ToNav for hir::Module {
             }
         };
         let frange = src.with_value(syntax).original_file_range(db);
-        NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, syntax.kind())
+        NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, SymbolKind::Module)
     }
 }
 
@@ -252,7 +328,7 @@ impl ToNav for hir::Impl {
             "impl".into(),
             focus_range,
             frange.range,
-            src.value.syntax().kind(),
+            SymbolKind::Impl,
         )
     }
 }
@@ -263,7 +339,8 @@ impl ToNav for hir::Field {
 
         match &src.value {
             FieldSource::Named(it) => {
-                let mut res = NavigationTarget::from_named(db, src.with_value(it));
+                let mut res =
+                    NavigationTarget::from_named(db, src.with_value(it), SymbolKind::Field);
                 res.docs = self.docs(db);
                 res.description = it.short_label();
                 res
@@ -275,7 +352,7 @@ impl ToNav for hir::Field {
                     "".into(),
                     None,
                     frange.range,
-                    it.syntax().kind(),
+                    SymbolKind::Field,
                 )
             }
         }
@@ -286,8 +363,11 @@ impl ToNav for hir::MacroDef {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
         log::debug!("nav target {:#?}", src.value.syntax());
-        let mut res =
-            NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
+        let mut res = NavigationTarget::from_named(
+            db,
+            src.as_ref().map(|it| it as &dyn ast::NameOwner),
+            SymbolKind::Macro,
+        );
         res.docs = self.docs(db);
         res
     }
@@ -327,10 +407,11 @@ impl ToNav for hir::Local {
             Some(it) => it.to_string().into(),
             None => "".into(),
         };
+        let kind = if self.is_param(db) { SymbolKind::ValueParam } else { SymbolKind::Local };
         NavigationTarget {
             file_id: full_range.file_id,
             name,
-            kind: IDENT_PAT,
+            kind: Some(kind),
             full_range: full_range.range,
             focus_range: None,
             container_name: None,
@@ -354,7 +435,7 @@ impl ToNav for hir::TypeParam {
         NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
-            kind: TYPE_PARAM,
+            kind: Some(SymbolKind::TypeParam),
             full_range,
             focus_range,
             container_name: None,
@@ -371,7 +452,7 @@ impl ToNav for hir::LifetimeParam {
         NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
-            kind: LIFETIME_PARAM,
+            kind: Some(SymbolKind::LifetimeParam),
             full_range,
             focus_range: Some(full_range),
             container_name: None,
@@ -428,34 +509,21 @@ fn foo() { enum FooInner { } }
                         0,
                     ),
                     full_range: 0..17,
-                    focus_range: Some(
-                        5..13,
-                    ),
+                    focus_range: 5..13,
                     name: "FooInner",
-                    kind: ENUM,
-                    container_name: None,
-                    description: Some(
-                        "enum FooInner",
-                    ),
-                    docs: None,
+                    kind: Enum,
+                    description: "enum FooInner",
                 },
                 NavigationTarget {
                     file_id: FileId(
                         0,
                     ),
                     full_range: 29..46,
-                    focus_range: Some(
-                        34..42,
-                    ),
+                    focus_range: 34..42,
                     name: "FooInner",
-                    kind: ENUM,
-                    container_name: Some(
-                        "foo",
-                    ),
-                    description: Some(
-                        "enum FooInner",
-                    ),
-                    docs: None,
+                    kind: Enum,
+                    container_name: "foo",
+                    description: "enum FooInner",
                 },
             ]
         "#]]
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index c51531391..32556dad3 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -1,15 +1,17 @@
 use syntax::{
     ast::{self, AttrsOwner, GenericParamsOwner, NameOwner},
-    match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, WalkEvent,
+    match_ast, AstNode, SourceFile, SyntaxNode, TextRange, WalkEvent,
 };
 
+use crate::SymbolKind;
+
 #[derive(Debug, Clone)]
 pub struct StructureNode {
     pub parent: Option<usize>,
     pub label: String,
     pub navigation_range: TextRange,
     pub node_range: TextRange,
-    pub kind: SyntaxKind,
+    pub kind: SymbolKind,
     pub detail: Option<String>,
     pub deprecated: bool,
 }
@@ -51,25 +53,27 @@ pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
 }
 
 fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
-    fn decl<N: NameOwner + AttrsOwner>(node: N) -> Option<StructureNode> {
-        decl_with_detail(&node, None)
+    fn decl<N: NameOwner + AttrsOwner>(node: N, kind: SymbolKind) -> Option<StructureNode> {
+        decl_with_detail(&node, None, kind)
     }
 
     fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
         node: &N,
         type_ref: Option<ast::Type>,
+        kind: SymbolKind,
     ) -> Option<StructureNode> {
         let detail = type_ref.map(|type_ref| {
             let mut detail = String::new();
             collapse_ws(type_ref.syntax(), &mut detail);
             detail
         });
-        decl_with_detail(node, detail)
+        decl_with_detail(node, detail, kind)
     }
 
     fn decl_with_detail<N: NameOwner + AttrsOwner>(
         node: &N,
         detail: Option<String>,
+        kind: SymbolKind,
     ) -> Option<StructureNode> {
         let name = node.name()?;
 
@@ -78,7 +82,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
             label: name.text().to_string(),
             navigation_range: name.syntax().text_range(),
             node_range: node.syntax().text_range(),
-            kind: node.syntax().kind(),
+            kind,
             detail,
             deprecated: node.attrs().filter_map(|x| x.simple_name()).any(|x| x == "deprecated"),
         })
@@ -117,18 +121,18 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                     collapse_ws(ret_type.syntax(), &mut detail);
                 }
 
-                decl_with_detail(&it, Some(detail))
+                decl_with_detail(&it, Some(detail), SymbolKind::Function)
             },
-            ast::Struct(it) => decl(it),
-            ast::Union(it) => decl(it),
-            ast::Enum(it) => decl(it),
-            ast::Variant(it) => decl(it),
-            ast::Trait(it) => decl(it),
-            ast::Module(it) => decl(it),
-            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty()),
-            ast::RecordField(it) => decl_with_type_ref(&it, it.ty()),
-            ast::Const(it) => decl_with_type_ref(&it, it.ty()),
-            ast::Static(it) => decl_with_type_ref(&it, it.ty()),
+            ast::Struct(it) => decl(it, SymbolKind::Struct),
+            ast::Union(it) => decl(it, SymbolKind::Union),
+            ast::Enum(it) => decl(it, SymbolKind::Enum),
+            ast::Variant(it) => decl(it, SymbolKind::Variant),
+            ast::Trait(it) => decl(it, SymbolKind::Trait),
+            ast::Module(it) => decl(it, SymbolKind::Module),
+            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::TypeAlias),
+            ast::RecordField(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Field),
+            ast::Const(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Const),
+            ast::Static(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Static),
             ast::Impl(it) => {
                 let target_type = it.self_ty()?;
                 let target_trait = it.trait_();
@@ -144,13 +148,13 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                     label,
                     navigation_range: target_type.syntax().text_range(),
                     node_range: it.syntax().text_range(),
-                    kind: it.syntax().kind(),
+                    kind: SymbolKind::Impl,
                     detail: None,
                     deprecated: false,
                 };
                 Some(node)
             },
-            ast::MacroRules(it) => decl(it),
+            ast::MacroRules(it) => decl(it, SymbolKind::Macro),
             _ => None,
         }
     }
@@ -222,7 +226,7 @@ fn very_obsolete() {}
                         label: "Foo",
                         navigation_range: 8..11,
                         node_range: 1..26,
-                        kind: STRUCT,
+                        kind: Struct,
                         detail: None,
                         deprecated: false,
                     },
@@ -233,7 +237,7 @@ fn very_obsolete() {}
                         label: "x",
                         navigation_range: 18..19,
                         node_range: 18..24,
-                        kind: RECORD_FIELD,
+                        kind: Field,
                         detail: Some(
                             "i32",
                         ),
@@ -244,7 +248,7 @@ fn very_obsolete() {}
                         label: "m",
                         navigation_range: 32..33,
                         node_range: 28..158,
-                        kind: MODULE,
+                        kind: Module,
                         detail: None,
                         deprecated: false,
                     },
@@ -255,7 +259,7 @@ fn very_obsolete() {}
                         label: "bar1",
                         navigation_range: 43..47,
                         node_range: 40..52,
-                        kind: FN,
+                        kind: Function,
                         detail: Some(
                             "fn()",
                         ),
@@ -268,7 +272,7 @@ fn very_obsolete() {}
                         label: "bar2",
                         navigation_range: 60..64,
                         node_range: 57..81,
-                        kind: FN,
+                        kind: Function,
                         detail: Some(
                             "fn<T>(t: T) -> T",
                         ),
@@ -281,7 +285,7 @@ fn very_obsolete() {}
                         label: "bar3",
                         navigation_range: 89..93,
                         node_range: 86..156,
-                        kind: FN,
+                        kind: Function,
                         detail: Some(
                             "fn<A, B>(a: A, b: B) -> Vec< u32 >",
                         ),
@@ -292,7 +296,7 @@ fn very_obsolete() {}
                         label: "E",
                         navigation_range: 165..166,
                         node_range: 160..180,
-                        kind: ENUM,
+                        kind: Enum,
                         detail: None,
                         deprecated: false,
                     },
@@ -303,7 +307,7 @@ fn very_obsolete() {}
                         label: "X",
                         navigation_range: 169..170,
                         node_range: 169..170,
-                        kind: VARIANT,
+                        kind: Variant,
                         detail: None,
                         deprecated: false,
                     },
@@ -314,7 +318,7 @@ fn very_obsolete() {}
                         label: "Y",
                         navigation_range: 172..173,
                         node_range: 172..178,
-                        kind: VARIANT,
+                        kind: Variant,
                         detail: None,
                         deprecated: false,
                     },
@@ -323,7 +327,7 @@ fn very_obsolete() {}
                         label: "T",
                         navigation_range: 186..187,
                         node_range: 181..193,
-                        kind: TYPE_ALIAS,
+                        kind: TypeAlias,
                         detail: Some(
                             "()",
                         ),
@@ -334,7 +338,7 @@ fn very_obsolete() {}
                         label: "S",
                         navigation_range: 201..202,
                         node_range: 194..213,
-                        kind: STATIC,
+                        kind: Static,
                         detail: Some(
                             "i32",
                         ),
@@ -345,7 +349,7 @@ fn very_obsolete() {}
                         label: "C",
                         navigation_range: 220..221,
                         node_range: 214..232,
-                        kind: CONST,
+                        kind: Const,
                         detail: Some(
                             "i32",
                         ),
@@ -356,7 +360,7 @@ fn very_obsolete() {}
                         label: "impl E",
                         navigation_range: 239..240,
                         node_range: 234..243,
-                        kind: IMPL,
+                        kind: Impl,
                         detail: None,
                         deprecated: false,
                     },
@@ -365,7 +369,7 @@ fn very_obsolete() {}
                         label: "impl fmt::Debug for E",
                         navigation_range: 265..266,
                         node_range: 245..269,
-                        kind: IMPL,
+                        kind: Impl,
                         detail: None,
                         deprecated: false,
                     },
@@ -374,7 +378,7 @@ fn very_obsolete() {}
                         label: "mc",
                         navigation_range: 284..286,
                         node_range: 271..303,
-                        kind: MACRO_RULES,
+                        kind: Macro,
                         detail: None,
                         deprecated: false,
                     },
@@ -383,7 +387,7 @@ fn very_obsolete() {}
                         label: "mcexp",
                         navigation_range: 334..339,
                         node_range: 305..356,
-                        kind: MACRO_RULES,
+                        kind: Macro,
                         detail: None,
                         deprecated: false,
                     },
@@ -392,7 +396,7 @@ fn very_obsolete() {}
                         label: "mcexp",
                         navigation_range: 387..392,
                         node_range: 358..409,
-                        kind: MACRO_RULES,
+                        kind: Macro,
                         detail: None,
                         deprecated: false,
                     },
@@ -401,7 +405,7 @@ fn very_obsolete() {}
                         label: "obsolete",
                         navigation_range: 428..436,
                         node_range: 411..441,
-                        kind: FN,
+                        kind: Function,
                         detail: Some(
                             "fn()",
                         ),
@@ -412,7 +416,7 @@ fn very_obsolete() {}
                         label: "very_obsolete",
                         navigation_range: 481..494,
                         node_range: 443..499,
-                        kind: FN,
+                        kind: Function,
                         detail: Some(
                             "fn()",
                         ),
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 173509b08..7a12e9965 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -9,7 +9,7 @@ use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset,
 
 use crate::{
     display::{ToNav, TryToNav},
-    FilePosition, NavigationTarget, RangeInfo,
+    FilePosition, NavigationTarget, RangeInfo, SymbolKind,
 };
 
 // Feature: Go to Definition
@@ -86,7 +86,7 @@ fn self_to_nav_target(self_param: ast::SelfParam, file_id: FileId) -> Option<Nav
         full_range: self_param.syntax().text_range(),
         focus_range: Some(self_token.text_range()),
         name: self_token.text().clone(),
-        kind: self_token.kind(),
+        kind: Some(SymbolKind::SelfParam),
         container_name: None,
         description: None,
         docs: None,
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index da6bb726a..b06fa5f15 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -2187,14 +2187,9 @@ fn foo_<|>test() {}
                                     0,
                                 ),
                                 full_range: 0..24,
-                                focus_range: Some(
-                                    11..19,
-                                ),
+                                focus_range: 11..19,
                                 name: "foo_test",
-                                kind: FN,
-                                container_name: None,
-                                description: None,
-                                docs: None,
+                                kind: Function,
                             },
                             kind: Test {
                                 test_id: Path(
@@ -2230,14 +2225,9 @@ mod tests<|> {
                                     0,
                                 ),
                                 full_range: 0..46,
-                                focus_range: Some(
-                                    4..9,
-                                ),
+                                focus_range: 4..9,
                                 name: "tests",
-                                kind: MODULE,
-                                container_name: None,
-                                description: None,
-                                docs: None,
+                                kind: Module,
                             },
                             kind: TestMod {
                                 path: "tests",
@@ -2269,16 +2259,10 @@ fn main() { let s<|>t = S{ f1:0 }; }
                                         0,
                                     ),
                                     full_range: 0..19,
-                                    focus_range: Some(
-                                        7..8,
-                                    ),
+                                    focus_range: 7..8,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -2308,16 +2292,10 @@ fn main() { let s<|>t = S{ f1:Arg(0) }; }
                                         0,
                                     ),
                                     full_range: 17..37,
-                                    focus_range: Some(
-                                        24..25,
-                                    ),
+                                    focus_range: 24..25,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2327,16 +2305,10 @@ fn main() { let s<|>t = S{ f1:Arg(0) }; }
                                         0,
                                     ),
                                     full_range: 0..16,
-                                    focus_range: Some(
-                                        7..10,
-                                    ),
+                                    focus_range: 7..10,
                                     name: "Arg",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct Arg",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct Arg",
                                 },
                             },
                         ],
@@ -2366,16 +2338,10 @@ fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
                                         0,
                                     ),
                                     full_range: 17..37,
-                                    focus_range: Some(
-                                        24..25,
-                                    ),
+                                    focus_range: 24..25,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2385,16 +2351,10 @@ fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
                                         0,
                                     ),
                                     full_range: 0..16,
-                                    focus_range: Some(
-                                        7..10,
-                                    ),
+                                    focus_range: 7..10,
                                     name: "Arg",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct Arg",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct Arg",
                                 },
                             },
                         ],
@@ -2427,16 +2387,10 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                         0,
                                     ),
                                     full_range: 0..14,
-                                    focus_range: Some(
-                                        7..8,
-                                    ),
+                                    focus_range: 7..8,
                                     name: "A",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct A",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct A",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2446,16 +2400,10 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                         0,
                                     ),
                                     full_range: 15..29,
-                                    focus_range: Some(
-                                        22..23,
-                                    ),
+                                    focus_range: 22..23,
                                     name: "B",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct B",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct B",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2465,16 +2413,10 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
                                         0,
                                     ),
                                     full_range: 42..60,
-                                    focus_range: Some(
-                                        53..54,
-                                    ),
+                                    focus_range: 53..54,
                                     name: "C",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "pub struct C",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "pub struct C",
                                 },
                             },
                         ],
@@ -2504,16 +2446,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                         ],
@@ -2544,16 +2480,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 0..15,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2563,16 +2493,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 16..25,
-                                    focus_range: Some(
-                                        23..24,
-                                    ),
+                                    focus_range: 23..24,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -2603,16 +2527,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2622,16 +2540,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 13..25,
-                                    focus_range: Some(
-                                        19..22,
-                                    ),
+                                    focus_range: 19..22,
                                     name: "Bar",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Bar",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Bar",
                                 },
                             },
                         ],
@@ -2665,16 +2577,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 0..15,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2684,16 +2590,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 16..31,
-                                    focus_range: Some(
-                                        22..25,
-                                    ),
+                                    focus_range: 22..25,
                                     name: "Bar",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Bar",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Bar",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2703,16 +2603,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 32..44,
-                                    focus_range: Some(
-                                        39..41,
-                                    ),
+                                    focus_range: 39..41,
                                     name: "S1",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S1",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S1",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2722,16 +2616,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 45..57,
-                                    focus_range: Some(
-                                        52..54,
-                                    ),
+                                    focus_range: 52..54,
                                     name: "S2",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S2",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S2",
                                 },
                             },
                         ],
@@ -2759,16 +2647,10 @@ fn foo(ar<|>g: &impl Foo) {}
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                         ],
@@ -2799,16 +2681,10 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2818,16 +2694,10 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                         0,
                                     ),
                                     full_range: 13..28,
-                                    focus_range: Some(
-                                        19..22,
-                                    ),
+                                    focus_range: 19..22,
                                     name: "Bar",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Bar",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Bar",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2837,16 +2707,10 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
                                         0,
                                     ),
                                     full_range: 29..39,
-                                    focus_range: Some(
-                                        36..37,
-                                    ),
+                                    focus_range: 36..37,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -2882,16 +2746,10 @@ mod future {
                                         0,
                                     ),
                                     full_range: 101..163,
-                                    focus_range: Some(
-                                        140..146,
-                                    ),
+                                    focus_range: 140..146,
                                     name: "Future",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "pub trait Future",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "pub trait Future",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2901,16 +2759,10 @@ mod future {
                                         0,
                                     ),
                                     full_range: 0..9,
-                                    focus_range: Some(
-                                        7..8,
-                                    ),
+                                    focus_range: 7..8,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -2939,16 +2791,10 @@ fn foo(ar<|>g: &impl Foo<S>) {}
                                         0,
                                     ),
                                     full_range: 0..15,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -2958,16 +2804,10 @@ fn foo(ar<|>g: &impl Foo<S>) {}
                                         0,
                                     ),
                                     full_range: 16..27,
-                                    focus_range: Some(
-                                        23..24,
-                                    ),
+                                    focus_range: 23..24,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -3001,16 +2841,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 42..55,
-                                    focus_range: Some(
-                                        49..50,
-                                    ),
+                                    focus_range: 49..50,
                                     name: "B",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct B",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct B",
                                 },
                             },
                             HoverGotoTypeData {
@@ -3020,16 +2854,10 @@ fn main() { let s<|>t = foo(); }
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                         ],
@@ -3057,16 +2885,10 @@ fn foo(ar<|>g: &dyn Foo) {}
                                         0,
                                     ),
                                     full_range: 0..12,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                         ],
@@ -3095,16 +2917,10 @@ fn foo(ar<|>g: &dyn Foo<S>) {}
                                         0,
                                     ),
                                     full_range: 0..15,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                             HoverGotoTypeData {
@@ -3114,16 +2930,10 @@ fn foo(ar<|>g: &dyn Foo<S>) {}
                                         0,
                                     ),
                                     full_range: 16..27,
-                                    focus_range: Some(
-                                        23..24,
-                                    ),
+                                    focus_range: 23..24,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -3155,16 +2965,10 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                         0,
                                     ),
                                     full_range: 0..21,
-                                    focus_range: Some(
-                                        6..15,
-                                    ),
+                                    focus_range: 6..15,
                                     name: "ImplTrait",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait ImplTrait",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait ImplTrait",
                                 },
                             },
                             HoverGotoTypeData {
@@ -3174,16 +2978,10 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                         0,
                                     ),
                                     full_range: 43..57,
-                                    focus_range: Some(
-                                        50..51,
-                                    ),
+                                    focus_range: 50..51,
                                     name: "B",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct B",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct B",
                                 },
                             },
                             HoverGotoTypeData {
@@ -3193,16 +2991,10 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                         0,
                                     ),
                                     full_range: 22..42,
-                                    focus_range: Some(
-                                        28..36,
-                                    ),
+                                    focus_range: 28..36,
                                     name: "DynTrait",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait DynTrait",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait DynTrait",
                                 },
                             },
                             HoverGotoTypeData {
@@ -3212,16 +3004,10 @@ fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                         0,
                                     ),
                                     full_range: 58..69,
-                                    focus_range: Some(
-                                        65..66,
-                                    ),
+                                    focus_range: 65..66,
                                     name: "S",
-                                    kind: STRUCT,
-                                    container_name: None,
-                                    description: Some(
-                                        "struct S",
-                                    ),
-                                    docs: None,
+                                    kind: Struct,
+                                    description: "struct S",
                                 },
                             },
                         ],
@@ -3260,16 +3046,10 @@ fn main() { let s<|>t = test().get(); }
                                         0,
                                     ),
                                     full_range: 0..62,
-                                    focus_range: Some(
-                                        6..9,
-                                    ),
+                                    focus_range: 6..9,
                                     name: "Foo",
-                                    kind: TRAIT,
-                                    container_name: None,
-                                    description: Some(
-                                        "trait Foo",
-                                    ),
-                                    docs: None,
+                                    kind: Trait,
+                                    description: "trait Foo",
                                 },
                             },
                         ],
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index c5c652cda..dbad9a84f 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -57,14 +57,14 @@ use ide_db::{
     symbol_index::{self, FileSymbol},
     LineIndexDatabase,
 };
-use syntax::{SourceFile, TextRange, TextSize};
+use syntax::SourceFile;
 
 use crate::display::ToNav;
 
 pub use crate::{
     call_hierarchy::CallItem,
     diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
-    display::NavigationTarget,
+    display::navigation_target::{NavigationTarget, SymbolKind},
     expand_macro::ExpandedMacro,
     file_structure::StructureNode,
     folding_ranges::{Fold, FoldKind},
@@ -79,22 +79,21 @@ pub use crate::{
         HighlightedRange,
     },
 };
+pub use assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
 pub use completion::{
     CompletionConfig, CompletionItem, CompletionItemKind, CompletionResolveCapability,
     CompletionScore, ImportEdit, InsertTextFormat,
 };
-pub use ide_db::{
-    call_info::CallInfo,
-    search::{Reference, ReferenceAccess, ReferenceKind},
-};
-
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
 pub use hir::{Documentation, Semantics};
 pub use ide_db::base_db::{
     Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
     SourceRootId,
 };
 pub use ide_db::{
+    call_info::CallInfo,
+    search::{Reference, ReferenceAccess, ReferenceKind},
+};
+pub use ide_db::{
     label::Label,
     line_index::{LineCol, LineIndex},
     search::SearchScope,
@@ -103,6 +102,7 @@ pub use ide_db::{
     RootDatabase,
 };
 pub use ssr::SsrError;
+pub use syntax::{TextRange, TextSize};
 pub use text_edit::{Indel, TextEdit};
 
 pub type Cancelable<T> = Result<T, Canceled>;
diff --git a/crates/ide/src/parent_module.rs b/crates/ide/src/parent_module.rs
index 6cc3b2991..be344a09b 100644
--- a/crates/ide/src/parent_module.rs
+++ b/crates/ide/src/parent_module.rs
@@ -78,7 +78,7 @@ mod tests {
             ",
         );
         let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("foo MODULE FileId(0) 0..8");
+        nav.assert_match("foo Module FileId(0) 0..8");
     }
 
     #[test]
@@ -97,7 +97,7 @@ mod tests {
             ",
         );
         let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("foo MODULE FileId(0) 0..8");
+        nav.assert_match("foo Module FileId(0) 0..8");
     }
 
     #[test]
@@ -113,7 +113,7 @@ mod tests {
             ",
         );
         let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("baz MODULE FileId(0) 32..44");
+        nav.assert_match("baz Module FileId(0) 32..44");
     }
 
     #[test]
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 98190a86b..18ea19305 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -24,7 +24,7 @@ use syntax::{
     match_ast, AstNode, SyntaxKind, SyntaxNode, TextRange, TokenAtOffset,
 };
 
-use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
+use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo, SymbolKind};
 
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
@@ -278,7 +278,7 @@ fn try_find_self_references(
             full_range: self_param.syntax().text_range(),
             focus_range: Some(param_self_token.text_range()),
             name: param_self_token.text().clone(),
-            kind: param_self_token.kind(),
+            kind: Some(SymbolKind::SelfParam),
             container_name: None,
             description: None,
             docs: None,
@@ -343,7 +343,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(0) 0..26 7..10 Other
+                Foo Struct FileId(0) 0..26 7..10 Other
 
                 FileId(0) 101..104 StructLiteral
             "#]],
@@ -361,7 +361,7 @@ struct Foo<|> {}
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(0) 0..13 7..10 Other
+                Foo Struct FileId(0) 0..13 7..10 Other
 
                 FileId(0) 41..44 Other
                 FileId(0) 54..57 StructLiteral
@@ -380,7 +380,7 @@ struct Foo<T> <|>{}
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(0) 0..16 7..10 Other
+                Foo Struct FileId(0) 0..16 7..10 Other
 
                 FileId(0) 64..67 StructLiteral
             "#]],
@@ -399,7 +399,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(0) 0..16 7..10 Other
+                Foo Struct FileId(0) 0..16 7..10 Other
 
                 FileId(0) 54..57 StructLiteral
             "#]],
@@ -420,7 +420,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo ENUM FileId(0) 0..26 5..8 Other
+                Foo Enum FileId(0) 0..26 5..8 Other
 
                 FileId(0) 63..66 EnumLiteral
             "#]],
@@ -441,7 +441,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo ENUM FileId(0) 0..26 5..8 Other
+                Foo Enum FileId(0) 0..26 5..8 Other
 
                 FileId(0) 50..53 Other
                 FileId(0) 63..66 EnumLiteral
@@ -463,7 +463,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo ENUM FileId(0) 0..32 5..8 Other
+                Foo Enum FileId(0) 0..32 5..8 Other
 
                 FileId(0) 73..76 EnumLiteral
             "#]],
@@ -484,7 +484,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo ENUM FileId(0) 0..33 5..8 Other
+                Foo Enum FileId(0) 0..33 5..8 Other
 
                 FileId(0) 70..73 EnumLiteral
             "#]],
@@ -507,7 +507,7 @@ fn main() {
     i = 5;
 }"#,
             expect![[r#"
-                i IDENT_PAT FileId(0) 24..25 Other Write
+                i Local FileId(0) 24..25 Other Write
 
                 FileId(0) 50..51 Other Write
                 FileId(0) 54..55 Other Read
@@ -531,7 +531,7 @@ fn bar() {
 }
 "#,
             expect![[r#"
-                spam IDENT_PAT FileId(0) 19..23 Other
+                spam Local FileId(0) 19..23 Other
 
                 FileId(0) 34..38 Other Read
                 FileId(0) 41..45 Other Read
@@ -546,7 +546,7 @@ fn bar() {
 fn foo(i : u32) -> u32 { i<|> }
 "#,
             expect![[r#"
-                i IDENT_PAT FileId(0) 7..8 Other
+                i ValueParam FileId(0) 7..8 Other
 
                 FileId(0) 25..26 Other Read
             "#]],
@@ -560,7 +560,7 @@ fn foo(i : u32) -> u32 { i<|> }
 fn foo(i<|> : u32) -> u32 { i }
 "#,
             expect![[r#"
-                i IDENT_PAT FileId(0) 7..8 Other
+                i ValueParam FileId(0) 7..8 Other
 
                 FileId(0) 25..26 Other Read
             "#]],
@@ -581,7 +581,7 @@ fn main(s: Foo) {
 }
 "#,
             expect![[r#"
-                spam RECORD_FIELD FileId(0) 17..30 21..25 Other
+                spam Field FileId(0) 17..30 21..25 Other
 
                 FileId(0) 67..71 Other Read
             "#]],
@@ -598,7 +598,7 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                f FN FileId(0) 27..43 30..31 Other
+                f Function FileId(0) 27..43 30..31 Other
 
             "#]],
         );
@@ -615,7 +615,7 @@ enum Foo {
 }
 "#,
             expect![[r#"
-                B VARIANT FileId(0) 22..23 22..23 Other
+                B Variant FileId(0) 22..23 22..23 Other
 
             "#]],
         );
@@ -632,7 +632,7 @@ enum Foo {
 }
 "#,
             expect![[r#"
-                field RECORD_FIELD FileId(0) 26..35 26..31 Other
+                field Field FileId(0) 26..35 26..31 Other
 
             "#]],
         );
@@ -673,7 +673,7 @@ fn f() {
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(1) 17..51 28..31 Other
+                Foo Struct FileId(1) 17..51 28..31 Other
 
                 FileId(0) 53..56 StructLiteral
                 FileId(2) 79..82 StructLiteral
@@ -703,7 +703,7 @@ pub struct Foo {
 }
 "#,
             expect![[r#"
-                foo SOURCE_FILE FileId(1) 0..35 Other
+                foo Module FileId(1) 0..35 Other
 
                 FileId(0) 14..17 Other
             "#]],
@@ -731,7 +731,7 @@ pub(super) struct Foo<|> {
 }
 "#,
             expect![[r#"
-                Foo STRUCT FileId(2) 0..41 18..21 Other
+                Foo Struct FileId(2) 0..41 18..21 Other
 
                 FileId(1) 20..23 Other
                 FileId(1) 47..50 StructLiteral
@@ -759,7 +759,7 @@ pub(super) struct Foo<|> {
             code,
             None,
             expect![[r#"
-                quux FN FileId(0) 19..35 26..30 Other
+                quux Function FileId(0) 19..35 26..30 Other
 
                 FileId(1) 16..20 StructLiteral
                 FileId(2) 16..20 StructLiteral
@@ -770,7 +770,7 @@ pub(super) struct Foo<|> {
             code,
             Some(SearchScope::single_file(FileId(2))),
             expect![[r#"
-                quux FN FileId(0) 19..35 26..30 Other
+                quux Function FileId(0) 19..35 26..30 Other
 
                 FileId(2) 16..20 StructLiteral
             "#]],
@@ -790,7 +790,7 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                m1 MACRO_RULES FileId(0) 0..46 29..31 Other
+                m1 Macro FileId(0) 0..46 29..31 Other
 
                 FileId(0) 63..65 StructLiteral
                 FileId(0) 73..75 StructLiteral
@@ -808,7 +808,7 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                i IDENT_PAT FileId(0) 23..24 Other Write
+                i Local FileId(0) 23..24 Other Write
 
                 FileId(0) 34..35 Other Write
                 FileId(0) 38..39 Other Read
@@ -830,7 +830,7 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                f RECORD_FIELD FileId(0) 15..21 15..16 Other
+                f Field FileId(0) 15..21 15..16 Other
 
                 FileId(0) 55..56 RecordFieldExprOrPat Read
                 FileId(0) 68..69 Other Write
@@ -848,7 +848,7 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                i IDENT_PAT FileId(0) 19..20 Other
+                i Local FileId(0) 19..20 Other
 
                 FileId(0) 26..27 Other Write
             "#]],
@@ -872,7 +872,7 @@ fn main() {
 }
 "#,
             expect![[r#"
-                new FN FileId(0) 54..81 61..64 Other
+                new Function FileId(0) 54..81 61..64 Other
 
                 FileId(0) 126..129 StructLiteral
             "#]],
@@ -894,7 +894,7 @@ use crate::f;
 fn g() { f(); }
 "#,
             expect![[r#"
-                f FN FileId(0) 22..31 25..26 Other
+                f Function FileId(0) 22..31 25..26 Other
 
                 FileId(1) 11..12 Other
                 FileId(1) 24..25 StructLiteral
@@ -917,7 +917,7 @@ fn f(s: S) {
 }
 "#,
             expect![[r#"
-                field RECORD_FIELD FileId(0) 15..24 15..20 Other
+                field Field FileId(0) 15..24 15..20 Other
 
                 FileId(0) 68..73 FieldShorthandForField Read
             "#]],
@@ -941,7 +941,7 @@ fn f(e: En) {
 }
 "#,
             expect![[r#"
-                field RECORD_FIELD FileId(0) 32..41 32..37 Other
+                field Field FileId(0) 32..41 32..37 Other
 
                 FileId(0) 102..107 FieldShorthandForField Read
             "#]],
@@ -965,7 +965,7 @@ fn f() -> m::En {
 }
 "#,
             expect![[r#"
-                field RECORD_FIELD FileId(0) 56..65 56..61 Other
+                field Field FileId(0) 56..65 56..61 Other
 
                 FileId(0) 125..130 RecordFieldExprOrPat Read
             "#]],
@@ -990,7 +990,7 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                self SELF_KW FileId(0) 47..51 47..51 SelfKw Read
+                self SelfParam FileId(0) 47..51 47..51 SelfKw Read
 
                 FileId(0) 71..75 SelfKw Read
                 FileId(0) 152..156 SelfKw Read
@@ -1038,7 +1038,7 @@ fn foo<'a, 'b: 'a>(x: &'a<|> ()) -> &'a () where &'a (): Foo<'a> {
 }
 "#,
             expect![[r#"
-                'a LIFETIME_PARAM FileId(0) 55..57 55..57 Lifetime
+                'a LifetimeParam FileId(0) 55..57 55..57 Lifetime
 
                 FileId(0) 63..65 Lifetime
                 FileId(0) 71..73 Lifetime
@@ -1056,7 +1056,7 @@ fn foo<'a, 'b: 'a>(x: &'a<|> ()) -> &'a () where &'a (): Foo<'a> {
 type Foo<'a, T> where T: 'a<|> = &'a T;
 "#,
             expect![[r#"
-                'a LIFETIME_PARAM FileId(0) 9..11 9..11 Lifetime
+                'a LifetimeParam FileId(0) 9..11 9..11 Lifetime
 
                 FileId(0) 25..27 Lifetime
                 FileId(0) 31..33 Lifetime
@@ -1078,7 +1078,7 @@ impl<'a> Foo<'a> for &'a () {
 }
 "#,
             expect![[r#"
-                'a LIFETIME_PARAM FileId(0) 47..49 47..49 Lifetime
+                'a LifetimeParam FileId(0) 47..49 47..49 Lifetime
 
                 FileId(0) 55..57 Lifetime
                 FileId(0) 64..66 Lifetime
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 56e923841..cd721b7eb 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1488,4 +1488,39 @@ impl<'yeeee> Foo<'yeeee> for &'yeeee () {
 "#,
         )
     }
+
+    #[test]
+    fn test_rename_bind_pat() {
+        check(
+            "new_name",
+            r#"
+fn main() {
+    enum CustomOption<T> {
+        None,
+        Some(T),
+    }
+
+    let test_variable = CustomOption::Some(22);
+
+    match test_variable {
+        CustomOption::Some(foo<|>) if foo == 11 => {}
+        _ => (),
+    }
+}"#,
+            r#"
+fn main() {
+    enum CustomOption<T> {
+        None,
+        Some(T),
+    }
+
+    let test_variable = CustomOption::Some(22);
+
+    match test_variable {
+        CustomOption::Some(new_name) if new_name == 11 => {}
+        _ => (),
+    }
+}"#,
+        );
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 2f465c195..ff386be80 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -12,7 +12,7 @@ use syntax::{
 
 use crate::{
     display::{ToNav, TryToNav},
-    FileId, NavigationTarget,
+    FileId, NavigationTarget, SymbolKind,
 };
 
 #[derive(Debug, Clone)]
@@ -137,7 +137,11 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, func: ast::Fn, file_id: FileId) -
         }
     };
 
-    let nav = NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &func));
+    let nav = NavigationTarget::from_named(
+        sema.db,
+        InFile::new(file_id.into(), &func),
+        SymbolKind::Function,
+    );
     let cfg = def.attrs(sema.db).cfg();
     Some(Runnable { nav, kind, cfg })
 }
@@ -204,7 +208,7 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
     nav.focus_range = None;
     nav.description = None;
     nav.docs = None;
-    nav.kind = syntax::SyntaxKind::COMMENT;
+    nav.kind = None;
     let res = Runnable { nav, kind: RunnableKind::DocTest { test_id }, cfg: attrs.cfg() };
     Some(res)
 }
@@ -348,14 +352,9 @@ fn bench() {}
                                 0,
                             ),
                             full_range: 1..13,
-                            focus_range: Some(
-                                4..8,
-                            ),
+                            focus_range: 4..8,
                             name: "main",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Bin,
                         cfg: None,
@@ -366,14 +365,9 @@ fn bench() {}
                                 0,
                             ),
                             full_range: 15..39,
-                            focus_range: Some(
-                                26..34,
-                            ),
+                            focus_range: 26..34,
                             name: "test_foo",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -391,14 +385,9 @@ fn bench() {}
                                 0,
                             ),
                             full_range: 41..75,
-                            focus_range: Some(
-                                62..70,
-                            ),
+                            focus_range: 62..70,
                             name: "test_foo",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -416,14 +405,9 @@ fn bench() {}
                                 0,
                             ),
                             full_range: 77..99,
-                            focus_range: Some(
-                                89..94,
-                            ),
+                            focus_range: 89..94,
                             name: "bench",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Bench {
                             test_id: Path(
@@ -513,14 +497,9 @@ struct StructWithRunnable(String);
                                 0,
                             ),
                             full_range: 1..13,
-                            focus_range: Some(
-                                4..8,
-                            ),
+                            focus_range: 4..8,
                             name: "main",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Bin,
                         cfg: None,
@@ -531,12 +510,7 @@ struct StructWithRunnable(String);
                                 0,
                             ),
                             full_range: 15..74,
-                            focus_range: None,
                             name: "should_have_runnable",
-                            kind: COMMENT,
-                            container_name: None,
-                            description: None,
-                            docs: None,
                         },
                         kind: DocTest {
                             test_id: Path(
@@ -551,12 +525,7 @@ struct StructWithRunnable(String);
                                 0,
                             ),
                             full_range: 76..148,
-                            focus_range: None,
                             name: "should_have_runnable_1",
-                            kind: COMMENT,
-                            container_name: None,
-                            description: None,
-                            docs: None,
                         },
                         kind: DocTest {
                             test_id: Path(
@@ -571,12 +540,7 @@ struct StructWithRunnable(String);
                                 0,
                             ),
                             full_range: 150..254,
-                            focus_range: None,
                             name: "should_have_runnable_2",
-                            kind: COMMENT,
-                            container_name: None,
-                            description: None,
-                            docs: None,
                         },
                         kind: DocTest {
                             test_id: Path(
@@ -591,12 +555,7 @@ struct StructWithRunnable(String);
                                 0,
                             ),
                             full_range: 756..821,
-                            focus_range: None,
                             name: "StructWithRunnable",
-                            kind: COMMENT,
-                            container_name: None,
-                            description: None,
-                            docs: None,
                         },
                         kind: DocTest {
                             test_id: Path(
@@ -635,14 +594,9 @@ impl Data {
                                 0,
                             ),
                             full_range: 1..13,
-                            focus_range: Some(
-                                4..8,
-                            ),
+                            focus_range: 4..8,
                             name: "main",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Bin,
                         cfg: None,
@@ -653,12 +607,7 @@ impl Data {
                                 0,
                             ),
                             full_range: 44..98,
-                            focus_range: None,
                             name: "foo",
-                            kind: COMMENT,
-                            container_name: None,
-                            description: None,
-                            docs: None,
                         },
                         kind: DocTest {
                             test_id: Path(
@@ -692,14 +641,9 @@ mod test_mod {
                                 0,
                             ),
                             full_range: 1..51,
-                            focus_range: Some(
-                                5..13,
-                            ),
+                            focus_range: 5..13,
                             name: "test_mod",
-                            kind: MODULE,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Module,
                         },
                         kind: TestMod {
                             path: "test_mod",
@@ -712,14 +656,9 @@ mod test_mod {
                                 0,
                             ),
                             full_range: 20..49,
-                            focus_range: Some(
-                                35..44,
-                            ),
+                            focus_range: 35..44,
                             name: "test_foo1",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -772,14 +711,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 22..323,
-                            focus_range: Some(
-                                26..40,
-                            ),
+                            focus_range: 26..40,
                             name: "nested_tests_0",
-                            kind: MODULE,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Module,
                         },
                         kind: TestMod {
                             path: "root_tests::nested_tests_0",
@@ -792,14 +726,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 51..192,
-                            focus_range: Some(
-                                55..69,
-                            ),
+                            focus_range: 55..69,
                             name: "nested_tests_1",
-                            kind: MODULE,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Module,
                         },
                         kind: TestMod {
                             path: "root_tests::nested_tests_0::nested_tests_1",
@@ -812,14 +741,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 84..126,
-                            focus_range: Some(
-                                107..121,
-                            ),
+                            focus_range: 107..121,
                             name: "nested_test_11",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -837,14 +761,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 140..182,
-                            focus_range: Some(
-                                163..177,
-                            ),
+                            focus_range: 163..177,
                             name: "nested_test_12",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -862,14 +781,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 202..286,
-                            focus_range: Some(
-                                206..220,
-                            ),
+                            focus_range: 206..220,
                             name: "nested_tests_2",
-                            kind: MODULE,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Module,
                         },
                         kind: TestMod {
                             path: "root_tests::nested_tests_0::nested_tests_2",
@@ -882,14 +796,9 @@ mod root_tests {
                                 0,
                             ),
                             full_range: 235..276,
-                            focus_range: Some(
-                                258..271,
-                            ),
+                            focus_range: 258..271,
                             name: "nested_test_2",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -925,14 +834,9 @@ fn test_foo1() {}
                                 0,
                             ),
                             full_range: 1..50,
-                            focus_range: Some(
-                                36..45,
-                            ),
+                            focus_range: 36..45,
                             name: "test_foo1",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
@@ -975,14 +879,9 @@ fn test_foo1() {}
                                 0,
                             ),
                             full_range: 1..72,
-                            focus_range: Some(
-                                58..67,
-                            ),
+                            focus_range: 58..67,
                             name: "test_foo1",
-                            kind: FN,
-                            container_name: None,
-                            description: None,
-                            docs: None,
+                            kind: Function,
                         },
                         kind: Test {
                             test_id: Path(
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 488969f1a..67ad7c63d 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -23,7 +23,7 @@ use crate::{
     syntax_highlighting::{
         format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
     },
-    FileId, HighlightModifier, HighlightTag,
+    FileId, HighlightModifier, HighlightTag, SymbolKind,
 };
 
 pub(crate) use html::highlight_as_html;
@@ -103,7 +103,7 @@ pub(crate) fn highlight(
                 if let Some(range) = macro_call_range(&mc) {
                     stack.add(HighlightedRange {
                         range,
-                        highlight: HighlightTag::Macro.into(),
+                        highlight: HighlightTag::Symbol(SymbolKind::Macro).into(),
                         binding_hash: None,
                     });
                 }
@@ -470,13 +470,13 @@ fn highlight_element(
             };
 
             match name_kind {
-                Some(NameClass::ExternCrate(_)) => HighlightTag::Module.into(),
+                Some(NameClass::ExternCrate(_)) => HighlightTag::Symbol(SymbolKind::Module).into(),
                 Some(NameClass::Definition(def)) => {
                     highlight_def(db, def) | HighlightModifier::Definition
                 }
                 Some(NameClass::ConstReference(def)) => highlight_def(db, def),
                 Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
-                    let mut h = HighlightTag::Field.into();
+                    let mut h = HighlightTag::Symbol(SymbolKind::Field).into();
                     if let Definition::Field(field) = field_ref {
                         if let VariantDef::Union(_) = field.parent_def(db) {
                             h |= HighlightModifier::Unsafe;
@@ -493,14 +493,16 @@ fn highlight_element(
         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(HighlightTag::Function)
+            Highlight::from(HighlightTag::Symbol(SymbolKind::Function))
         }
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
             highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
                 match NameRefClass::classify(sema, &name_ref) {
                     Some(name_kind) => match name_kind {
-                        NameRefClass::ExternCrate(_) => HighlightTag::Module.into(),
+                        NameRefClass::ExternCrate(_) => {
+                            HighlightTag::Symbol(SymbolKind::Module).into()
+                        }
                         NameRefClass::Definition(def) => {
                             if let Definition::Local(local) = &def {
                                 if let Some(name) = local.name(db) {
@@ -530,7 +532,9 @@ fn highlight_element(
 
                             h
                         }
-                        NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
+                        NameRefClass::FieldShorthand { .. } => {
+                            HighlightTag::Symbol(SymbolKind::Field).into()
+                        }
                     },
                     None if syntactic_name_ref_highlighting => {
                         highlight_name_ref_by_syntax(name_ref, sema)
@@ -556,7 +560,7 @@ fn highlight_element(
         CHAR => HighlightTag::CharLiteral.into(),
         QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow,
         LIFETIME => {
-            let h = Highlight::new(HighlightTag::Lifetime);
+            let h = Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam));
             match element.parent().map(|it| it.kind()) {
                 Some(LIFETIME_PARAM) | Some(LABEL) => h | HighlightModifier::Definition,
                 _ => h,
@@ -580,7 +584,7 @@ fn highlight_element(
                 HighlightTag::Operator.into()
             }
             T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
-                HighlightTag::Macro.into()
+                HighlightTag::Symbol(SymbolKind::Macro).into()
             }
             T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
                 HighlightTag::BuiltinType.into()
@@ -659,7 +663,7 @@ fn highlight_element(
                         .and_then(SyntaxNode::parent)
                         .and_then(ast::Path::cast)
                         .and_then(|p| sema.resolve_path(&p));
-                    let mut h = HighlightTag::SelfKeyword.into();
+                    let mut h = HighlightTag::Symbol(SymbolKind::SelfParam).into();
                     if self_param_is_mut
                         || matches!(self_path,
                             Some(hir::PathResolution::Local(local))
@@ -732,7 +736,8 @@ fn highlight_method_call(
     method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
     let func = sema.resolve_method_call(&method_call)?;
-    let mut h = HighlightTag::Method.into();
+    let mut h = HighlightTag::Symbol(SymbolKind::Function).into();
+    h |= HighlightModifier::Associated;
     if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
         h |= HighlightModifier::Unsafe;
     }
@@ -756,35 +761,45 @@ fn highlight_method_call(
 
 fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
     match def {
-        Definition::Macro(_) => HighlightTag::Macro,
-        Definition::Field(_) => HighlightTag::Field,
+        Definition::Macro(_) => HighlightTag::Symbol(SymbolKind::Macro),
+        Definition::Field(_) => HighlightTag::Symbol(SymbolKind::Field),
         Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(_) => HighlightTag::Module,
+            hir::ModuleDef::Module(_) => HighlightTag::Symbol(SymbolKind::Module),
             hir::ModuleDef::Function(func) => {
-                let mut h = if func.as_assoc_item(db).is_some() {
+                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Function));
+                if func.as_assoc_item(db).is_some() {
+                    h |= HighlightModifier::Associated;
                     if func.self_param(db).is_none() {
-                        Highlight::from(HighlightTag::Method) | HighlightModifier::Static
-                    } else {
-                        HighlightTag::Method.into()
+                        h |= HighlightModifier::Static
                     }
-                } else {
-                    HighlightTag::Function.into()
-                };
+                }
                 if func.is_unsafe(db) {
                     h |= HighlightModifier::Unsafe;
                 }
                 return h;
             }
-            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Struct,
-            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Enum,
-            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
-            hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
-            hir::ModuleDef::Const(_) => HighlightTag::Constant,
-            hir::ModuleDef::Trait(_) => HighlightTag::Trait,
-            hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
+            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Symbol(SymbolKind::Struct),
+            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Symbol(SymbolKind::Enum),
+            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Symbol(SymbolKind::Union),
+            hir::ModuleDef::EnumVariant(_) => HighlightTag::Symbol(SymbolKind::Variant),
+            hir::ModuleDef::Const(konst) => {
+                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Const));
+                if konst.as_assoc_item(db).is_some() {
+                    h |= HighlightModifier::Associated
+                }
+                return h;
+            }
+            hir::ModuleDef::Trait(_) => HighlightTag::Symbol(SymbolKind::Trait),
+            hir::ModuleDef::TypeAlias(type_) => {
+                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::TypeAlias));
+                if type_.as_assoc_item(db).is_some() {
+                    h |= HighlightModifier::Associated
+                }
+                return h;
+            }
             hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
             hir::ModuleDef::Static(s) => {
-                let mut h = Highlight::new(HighlightTag::Static);
+                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Static));
                 if s.is_mut(db) {
                     h |= HighlightModifier::Mutable;
                     h |= HighlightModifier::Unsafe;
@@ -792,11 +807,14 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                 return h;
             }
         },
-        Definition::SelfType(_) => HighlightTag::SelfType,
-        Definition::TypeParam(_) => HighlightTag::TypeParam,
+        Definition::SelfType(_) => HighlightTag::Symbol(SymbolKind::Impl),
+        Definition::TypeParam(_) => HighlightTag::Symbol(SymbolKind::TypeParam),
         Definition::Local(local) => {
-            let tag =
-                if local.is_param(db) { HighlightTag::ValueParam } else { HighlightTag::Local };
+            let tag = if local.is_param(db) {
+                HighlightTag::Symbol(SymbolKind::ValueParam)
+            } else {
+                HighlightTag::Symbol(SymbolKind::Local)
+            };
             let mut h = Highlight::new(tag);
             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
                 h |= HighlightModifier::Mutable;
@@ -806,7 +824,7 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
             }
             return h;
         }
-        Definition::LifetimeParam(_) => HighlightTag::Lifetime,
+        Definition::LifetimeParam(_) => HighlightTag::Symbol(SymbolKind::LifetimeParam),
     }
     .into()
 }
@@ -820,19 +838,19 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
     };
 
     let tag = match parent.kind() {
-        STRUCT => HighlightTag::Struct,
-        ENUM => HighlightTag::Enum,
-        UNION => HighlightTag::Union,
-        TRAIT => HighlightTag::Trait,
-        TYPE_ALIAS => HighlightTag::TypeAlias,
-        TYPE_PARAM => HighlightTag::TypeParam,
-        RECORD_FIELD => HighlightTag::Field,
-        MODULE => HighlightTag::Module,
-        FN => HighlightTag::Function,
-        CONST => HighlightTag::Constant,
-        STATIC => HighlightTag::Static,
-        VARIANT => HighlightTag::EnumVariant,
-        IDENT_PAT => HighlightTag::Local,
+        STRUCT => HighlightTag::Symbol(SymbolKind::Struct),
+        ENUM => HighlightTag::Symbol(SymbolKind::Enum),
+        VARIANT => HighlightTag::Symbol(SymbolKind::Variant),
+        UNION => HighlightTag::Symbol(SymbolKind::Union),
+        TRAIT => HighlightTag::Symbol(SymbolKind::Trait),
+        TYPE_ALIAS => HighlightTag::Symbol(SymbolKind::TypeAlias),
+        TYPE_PARAM => HighlightTag::Symbol(SymbolKind::TypeParam),
+        RECORD_FIELD => HighlightTag::Symbol(SymbolKind::Field),
+        MODULE => HighlightTag::Symbol(SymbolKind::Module),
+        FN => HighlightTag::Symbol(SymbolKind::Function),
+        CONST => HighlightTag::Symbol(SymbolKind::Const),
+        STATIC => HighlightTag::Symbol(SymbolKind::Static),
+        IDENT_PAT => HighlightTag::Symbol(SymbolKind::Local),
         _ => default,
     };
 
@@ -851,10 +869,10 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
         METHOD_CALL_EXPR => {
             return ast::MethodCallExpr::cast(parent)
                 .and_then(|method_call| highlight_method_call(sema, &method_call))
-                .unwrap_or_else(|| HighlightTag::Function.into());
+                .unwrap_or_else(|| HighlightTag::Symbol(SymbolKind::Function).into());
         }
         FIELD_EXPR => {
-            let h = HighlightTag::Field;
+            let h = HighlightTag::Symbol(SymbolKind::Field);
             let is_union = ast::FieldExpr::cast(parent)
                 .and_then(|field_expr| {
                     let field = sema.resolve_field(&field_expr)?;
@@ -881,9 +899,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() {
-                        HighlightTag::Struct
+                        HighlightTag::Symbol(SymbolKind::Struct)
                     } else {
-                        HighlightTag::Module
+                        HighlightTag::Symbol(SymbolKind::Module)
                     }
                     .into();
                 }
@@ -894,11 +912,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
             };
 
             match parent.kind() {
-                CALL_EXPR => HighlightTag::Function.into(),
+                CALL_EXPR => HighlightTag::Symbol(SymbolKind::Function).into(),
                 _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                    HighlightTag::Struct.into()
+                    HighlightTag::Symbol(SymbolKind::Struct)
                 } else {
-                    HighlightTag::Constant
+                    HighlightTag::Symbol(SymbolKind::Const)
                 }
                 .into(),
             }
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 42f27df5d..26416022b 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -4,7 +4,9 @@ use syntax::{
     AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{syntax_highlighting::HighlightedRangeStack, HighlightTag, HighlightedRange};
+use crate::{
+    syntax_highlighting::HighlightedRangeStack, HighlightTag, HighlightedRange, SymbolKind,
+};
 
 #[derive(Default)]
 pub(super) struct FormatStringHighlighter {
@@ -71,6 +73,6 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
         | FormatSpecifier::Asterisk
         | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
         FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
-        FormatSpecifier::Identifier => HighlightTag::Local,
+        FormatSpecifier::Identifier => HighlightTag::Symbol(SymbolKind::Local),
     })
 }
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index e97d1be1a..9eb184c74 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -179,6 +179,5 @@ pub(super) fn highlight_doc_comment(
         stack.add(comment);
     }
     stack.pop_and_inject(None);
-    stack
-        .pop_and_inject(Some(Highlight::from(HighlightTag::Generic) | HighlightModifier::Injected));
+    stack.pop_and_inject(Some(Highlight::from(HighlightTag::Dummy) | HighlightModifier::Injected));
 }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index ffd9588b8..974f54fa0 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -3,6 +3,8 @@
 
 use std::{fmt, ops};
 
+use crate::SymbolKind;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Highlight {
     pub tag: HighlightTag,
@@ -14,40 +16,25 @@ pub struct HighlightModifiers(u32);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum HighlightTag {
-    Attribute,
+    Symbol(SymbolKind),
+
     BoolLiteral,
     BuiltinType,
     ByteLiteral,
     CharLiteral,
+    NumericLiteral,
+    StringLiteral,
+    Attribute,
     Comment,
-    Constant,
-    Enum,
-    EnumVariant,
     EscapeSequence,
-    Field,
-    Function,
-    Generic,
+    FormatSpecifier,
     Keyword,
-    Lifetime,
-    Macro,
-    Method,
-    Module,
-    NumericLiteral,
     Punctuation,
-    SelfKeyword,
-    SelfType,
-    Static,
-    StringLiteral,
-    Struct,
-    Trait,
-    TypeAlias,
-    TypeParam,
-    Union,
-    ValueParam,
-    Local,
-    UnresolvedReference,
-    FormatSpecifier,
     Operator,
+    UnresolvedReference,
+
+    // For things which don't have proper Tag, but want to use modifiers.
+    Dummy,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -64,48 +51,53 @@ pub enum HighlightModifier {
     Injected,
     Mutable,
     Consuming,
-    Unsafe,
     Callable,
     /// Used for associated functions
     Static,
+    /// Used for items in impls&traits.
+    Associated,
+
+    /// Keep this last!
+    Unsafe,
 }
 
 impl HighlightTag {
     fn as_str(self) -> &'static str {
         match self {
+            HighlightTag::Symbol(symbol) => match symbol {
+                SymbolKind::Const => "constant",
+                SymbolKind::Static => "static",
+                SymbolKind::Enum => "enum",
+                SymbolKind::Variant => "enum_variant",
+                SymbolKind::Struct => "struct",
+                SymbolKind::Union => "union",
+                SymbolKind::Field => "field",
+                SymbolKind::Module => "module",
+                SymbolKind::Trait => "trait",
+                SymbolKind::Function => "function",
+                SymbolKind::TypeAlias => "type_alias",
+                SymbolKind::TypeParam => "type_param",
+                SymbolKind::LifetimeParam => "lifetime",
+                SymbolKind::Macro => "macro",
+                SymbolKind::Local => "variable",
+                SymbolKind::ValueParam => "value_param",
+                SymbolKind::SelfParam => "self_keyword",
+                SymbolKind::Impl => "self_type",
+            },
             HighlightTag::Attribute => "attribute",
             HighlightTag::BoolLiteral => "bool_literal",
             HighlightTag::BuiltinType => "builtin_type",
             HighlightTag::ByteLiteral => "byte_literal",
             HighlightTag::CharLiteral => "char_literal",
             HighlightTag::Comment => "comment",
-            HighlightTag::Constant => "constant",
-            HighlightTag::Enum => "enum",
-            HighlightTag::EnumVariant => "enum_variant",
             HighlightTag::EscapeSequence => "escape_sequence",
-            HighlightTag::Field => "field",
             HighlightTag::FormatSpecifier => "format_specifier",
-            HighlightTag::Function => "function",
-            HighlightTag::Generic => "generic",
+            HighlightTag::Dummy => "dummy",
             HighlightTag::Keyword => "keyword",
-            HighlightTag::Lifetime => "lifetime",
             HighlightTag::Punctuation => "punctuation",
-            HighlightTag::Macro => "macro",
-            HighlightTag::Method => "method",
-            HighlightTag::Module => "module",
             HighlightTag::NumericLiteral => "numeric_literal",
             HighlightTag::Operator => "operator",
-            HighlightTag::SelfKeyword => "self_keyword",
-            HighlightTag::SelfType => "self_type",
-            HighlightTag::Static => "static",
             HighlightTag::StringLiteral => "string_literal",
-            HighlightTag::Struct => "struct",
-            HighlightTag::Trait => "trait",
-            HighlightTag::TypeAlias => "type_alias",
-            HighlightTag::TypeParam => "type_param",
-            HighlightTag::Union => "union",
-            HighlightTag::ValueParam => "value_param",
-            HighlightTag::Local => "variable",
             HighlightTag::UnresolvedReference => "unresolved_reference",
         }
     }
@@ -118,7 +110,7 @@ impl fmt::Display for HighlightTag {
 }
 
 impl HighlightModifier {
-    const ALL: &'static [HighlightModifier] = &[
+    const ALL: &'static [HighlightModifier; HighlightModifier::Unsafe as u8 as usize + 1] = &[
         HighlightModifier::Attribute,
         HighlightModifier::ControlFlow,
         HighlightModifier::Definition,
@@ -126,9 +118,10 @@ impl HighlightModifier {
         HighlightModifier::Injected,
         HighlightModifier::Mutable,
         HighlightModifier::Consuming,
-        HighlightModifier::Unsafe,
         HighlightModifier::Callable,
         HighlightModifier::Static,
+        HighlightModifier::Associated,
+        HighlightModifier::Unsafe,
     ];
 
     fn as_str(self) -> &'static str {
@@ -143,6 +136,7 @@ impl HighlightModifier {
             HighlightModifier::Unsafe => "unsafe",
             HighlightModifier::Callable => "callable",
             HighlightModifier::Static => "static",
+            HighlightModifier::Associated => "associated",
         }
     }
 
@@ -209,6 +203,10 @@ impl ops::BitOr<HighlightModifier> for Highlight {
 }
 
 impl HighlightModifiers {
+    pub fn contains(self, m: HighlightModifier) -> bool {
+        self.0 & m.mask() == m.mask()
+    }
+
     pub fn iter(self) -> impl Iterator<Item = HighlightModifier> {
         HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
     }
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 6fb606a47..db6f32d33 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
@@ -40,17 +40,17 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">foo</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="struct">foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="method declaration static">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="method declaration">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration static">t_is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">fn</span> <span class="method declaration">t_is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">fn</span> <span class="function declaration static associated">t_is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">t_is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="method declaration static">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="method declaration">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</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 920956b51..4e511baa9 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -36,24 +36,24 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">/// ```</span>
-<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="punctuation injected">_</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span><span class="punctuation injected">
+<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="punctuation injected">_</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span><span class="punctuation injected">
 </span><span class="comment documentation">/// ```</span>
 <span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
     <span class="field declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span><span class="punctuation">,</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="punctuation">;</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration associated">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="punctuation">;</span>
 
     <span class="comment documentation">/// Constructs a new `Foo`.</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// # Examples</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// #</span><span class="generic 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="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="keyword injected">mut</span><span class="generic injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
+    <span class="comment documentation">/// #</span><span class="dummy 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="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="keyword injected">mut</span><span class="dummy injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
 </span>    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="method declaration static">new</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</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="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
         <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">bar</span><span class="punctuation">:</span> <span class="bool_literal">true</span> <span class="punctuation">}</span>
     <span class="punctuation">}</span>
 
@@ -62,32 +62,32 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment documentation">/// # Examples</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="generic injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="dummy injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foo</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
-    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="generic injected">foo</span><span class="operator injected">.</span><span class="generic injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="dummy injected">foo</span><span class="operator injected">.</span><span class="dummy injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">bar</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="generic injected"> </span><span class="operator injected">||</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">bar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="dummy injected"> </span><span class="operator injected">||</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// </span><span class="comment injected">/* multi-line
     </span><span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="string_literal injected">"Foo
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"Foo
     </span><span class="comment documentation">/// </span><span class="string_literal injected">  bar
     </span><span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="punctuation injected">;</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```rust,no_run</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foobar</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foobar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
 </span>    <span class="comment documentation">/// ```</span>
     <span class="comment documentation">///</span>
     <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="method declaration">foo</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="punctuation">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">foo</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="punctuation">{</span>
         <span class="bool_literal">true</span>
     <span class="punctuation">}</span>
 <span class="punctuation">}</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 31daf2bd0..7f18ad297 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -40,7 +40,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
     <span class="function">fixture</span><span class="punctuation">(</span><span class="string_literal">r#"</span>
         <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="punctuation">{</span>
-            <span class="keyword">fn</span> <span class="method declaration static">foo</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
+            <span class="keyword">fn</span> <span class="function declaration static associated">foo</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
                 <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"2 + 2 = {}"</span><span class="punctuation">,</span> <span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">;</span>
             <span class="punctuation">}</span>
         <span class="punctuation">}</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 67ec73f15..d26f48516 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -45,7 +45,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="punctuation">;</span>
 
 <span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="punctuation">{</span>
-    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="method declaration unsafe">unsafe_method</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration associated unsafe">unsafe_method</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">struct</span> <span class="struct declaration">TypeForStaticMut</span> <span class="punctuation">{</span>
@@ -60,11 +60,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="punctuation">}</span>
 
 <span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
@@ -78,7 +78,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
             <span class="union">Union</span> <span class="punctuation">{</span> <span class="field unsafe">b</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span> <span class="operator">=&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
             <span class="union">Union</span> <span class="punctuation">{</span> <span class="field unsafe">a</span> <span class="punctuation">}</span> <span class="operator">=&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
         <span class="punctuation">}</span>
-        <span class="struct">HasUnsafeFn</span><span class="operator">.</span><span class="method unsafe">unsafe_method</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+        <span class="struct">HasUnsafeFn</span><span class="operator">.</span><span class="function associated unsafe">unsafe_method</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
 
         <span class="comment">// unsafe deref</span>
         <span class="keyword">let</span> <span class="variable declaration">y</span> <span class="operator">=</span> <span class="operator unsafe">*</span><span class="variable">x</span><span class="punctuation">;</span>
@@ -94,6 +94,6 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
         <span class="keyword">let</span> <span class="struct">Packed</span> <span class="punctuation">{</span> <span class="field">a</span><span class="punctuation">:</span> <span class="keyword unsafe">ref</span> <span class="variable declaration">_a</span> <span class="punctuation">}</span> <span class="operator">=</span> <span class="variable">packed</span><span class="punctuation">;</span>
 
         <span class="comment">// unsafe auto ref of packed field</span>
-        <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="operator">.</span><span class="method unsafe">calls_autoref</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+        <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="operator">.</span><span class="function associated unsafe">calls_autoref</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
     <span class="punctuation">}</span>
 <span class="punctuation">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 3530a5fdb..588e86a34 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -65,25 +65,25 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="punctuation">}</span>
 
 <span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="punctuation">;</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
     <span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">Foo</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
-        <span class="value_param">f</span><span class="operator">.</span><span class="method consuming">baz</span><span class="punctuation">(</span><span class="self_keyword mutable consuming">self</span><span class="punctuation">)</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">Foo</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="punctuation">(</span><span class="self_keyword mutable consuming">self</span><span class="punctuation">)</span>
     <span class="punctuation">}</span>
 
-    <span class="keyword">fn</span> <span class="method declaration">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</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="punctuation">;</span>
     <span class="punctuation">}</span>
 
-    <span class="keyword">fn</span> <span class="method declaration">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
     <span class="punctuation">}</span>
 <span class="punctuation">}</span>
@@ -94,15 +94,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="punctuation">}</span>
 
 <span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">FooCopy</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
-        <span class="value_param">f</span><span class="operator">.</span><span class="method">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">)</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">FooCopy</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">)</span>
     <span class="punctuation">}</span>
 
-    <span class="keyword">fn</span> <span class="method declaration">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</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="punctuation">;</span>
     <span class="punctuation">}</span>
 
-    <span class="keyword">fn</span> <span class="method declaration">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
     <span class="punctuation">}</span>
 <span class="punctuation">}</span>
@@ -178,17 +178,17 @@ 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="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="variable mutable">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
     <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="variable mutable">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="method">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="method mutable">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="method consuming">baz</span><span class="punctuation">(</span><span class="variable consuming">foo2</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="punctuation">(</span><span class="variable consuming">foo2</span><span class="punctuation">)</span><span class="punctuation">;</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="punctuation">{</span> <span class="field">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="method">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="method mutable">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="method">baz</span><span class="punctuation">(</span><span class="variable mutable">copy</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">baz</span><span class="punctuation">(</span><span class="variable mutable">copy</span><span class="punctuation">)</span><span class="punctuation">;</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="punctuation">;</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="method">baz</span><span class="punctuation">;</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="punctuation">;</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="punctuation">;</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="punctuation">;</span>
@@ -203,7 +203,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="punctuation">;</span>
 
 <span class="keyword">impl</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="method declaration">and</span><span class="punctuation">&lt;</span><span class="type_param declaration">U</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">other</span><span class="punctuation">:</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">U</span><span class="punctuation">&gt;</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">,</span> <span class="type_param">U</span><span class="punctuation">)</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">and</span><span class="punctuation">&lt;</span><span class="type_param declaration">U</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">other</span><span class="punctuation">:</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">U</span><span class="punctuation">&gt;</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">,</span> <span class="type_param">U</span><span class="punctuation">)</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
         <span class="keyword control">match</span> <span class="value_param">other</span> <span class="punctuation">{</span>
             <span class="enum_variant">None</span> <span class="operator">=&gt;</span> <span class="macro">unimplemented!</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
             <span class="variable declaration">Nope</span> <span class="operator">=&gt;</span> <span class="variable">Nope</span><span class="punctuation">,</span>
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 9be36d59b..d6b498be3 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -9,7 +9,7 @@ use syntax::{
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
-        make, AstNode, PathSegmentKind, VisibilityOwner,
+        make, AstNode, AttrsOwner, PathSegmentKind, VisibilityOwner,
     },
     AstToken, InsertPosition, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken,
 };
@@ -180,6 +180,15 @@ fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -
     }
 }
 
+fn eq_attrs(
+    attrs0: impl Iterator<Item = ast::Attr>,
+    attrs1: impl Iterator<Item = ast::Attr>,
+) -> bool {
+    let attrs0 = attrs0.map(|attr| attr.to_string());
+    let attrs1 = attrs1.map(|attr| attr.to_string());
+    attrs0.eq(attrs1)
+}
+
 pub fn try_merge_imports(
     lhs: &ast::Use,
     rhs: &ast::Use,
@@ -189,6 +198,10 @@ pub fn try_merge_imports(
     if !eq_visibility(lhs.visibility(), rhs.visibility()) {
         return None;
     }
+    if !eq_attrs(lhs.attrs(), rhs.attrs()) {
+        return None;
+    }
+
     let lhs_tree = lhs.use_tree()?;
     let rhs_tree = rhs.use_tree()?;
     let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behavior)?;
diff --git a/crates/ide_db/src/helpers/insert_use/tests.rs b/crates/ide_db/src/helpers/insert_use/tests.rs
index 9e194354e..a603fe87f 100644
--- a/crates/ide_db/src/helpers/insert_use/tests.rs
+++ b/crates/ide_db/src/helpers/insert_use/tests.rs
@@ -448,6 +448,20 @@ use std::io;",
 }
 
 #[test]
+fn merge_groups_skip_attributed() {
+    check_full(
+        "std::io",
+        r#"
+#[cfg(feature = "gated")] use std::fmt::{Result, Display};
+"#,
+        r#"
+#[cfg(feature = "gated")] use std::fmt::{Result, Display};
+use std::io;
+"#,
+    )
+}
+
+#[test]
 #[ignore] // FIXME: Support this
 fn split_out_merge() {
     check_last(
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index ca455fa03..0aa6a0765 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -39,7 +39,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
     ast::{self, NameOwner},
     match_ast, AstNode, Parse, SmolStr, SourceFile,
-    SyntaxKind::{self, *},
+    SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, TextRange, WalkEvent,
 };
 
@@ -323,7 +323,7 @@ impl Query {
                 let (start, end) = SymbolIndex::map_value_to_range(indexed_value.value);
 
                 for symbol in &symbol_index.symbols[start..end] {
-                    if self.only_types && !is_type(symbol.kind) {
+                    if self.only_types && !symbol.kind.is_type() {
                         continue;
                     }
                     if self.exact && symbol.name != self.query {
@@ -341,23 +341,44 @@ impl Query {
     }
 }
 
-fn is_type(kind: SyntaxKind) -> bool {
-    matches!(kind, STRUCT | ENUM | TRAIT | TYPE_ALIAS)
-}
-
 /// The actual data that is stored in the index. It should be as compact as
 /// possible.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FileSymbol {
     pub file_id: FileId,
     pub name: SmolStr,
-    pub kind: SyntaxKind,
+    pub kind: FileSymbolKind,
     pub range: TextRange,
     pub ptr: SyntaxNodePtr,
     pub name_range: Option<TextRange>,
     pub container_name: Option<SmolStr>,
 }
 
+#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
+pub enum FileSymbolKind {
+    Function,
+    Struct,
+    Enum,
+    Trait,
+    Module,
+    TypeAlias,
+    Const,
+    Static,
+    Macro,
+}
+
+impl FileSymbolKind {
+    fn is_type(self: FileSymbolKind) -> bool {
+        matches!(
+            self,
+            FileSymbolKind::Struct
+                | FileSymbolKind::Enum
+                | FileSymbolKind::Trait
+                | FileSymbolKind::TypeAlias
+        )
+    }
+}
+
 fn source_file_to_file_symbols(source_file: &SourceFile, file_id: FileId) -> Vec<FileSymbol> {
     let mut symbols = Vec::new();
     let mut stack = Vec::new();
@@ -412,7 +433,18 @@ fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
 fn to_file_symbol(node: &SyntaxNode, file_id: FileId) -> Option<FileSymbol> {
     to_symbol(node).map(move |(name, ptr, name_range)| FileSymbol {
         name,
-        kind: node.kind(),
+        kind: match node.kind() {
+            FN => FileSymbolKind::Function,
+            STRUCT => FileSymbolKind::Struct,
+            ENUM => FileSymbolKind::Enum,
+            TRAIT => FileSymbolKind::Trait,
+            MODULE => FileSymbolKind::Module,
+            TYPE_ALIAS => FileSymbolKind::TypeAlias,
+            CONST => FileSymbolKind::Const,
+            STATIC => FileSymbolKind::Static,
+            MACRO_RULES => FileSymbolKind::Macro,
+            kind => unreachable!("{:?}", kind),
+        },
         range: node.text_range(),
         ptr,
         file_id,
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 23039eba4..1a078f6b4 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -133,6 +133,10 @@ pub(crate) mod fragments {
 
         m.complete(p, MACRO_STMTS);
     }
+
+    pub(crate) fn attr(p: &mut Parser) {
+        attributes::outer_attrs(p)
+    }
 }
 
 pub(crate) fn reparser(
diff --git a/crates/parser/src/lib.rs b/crates/parser/src/lib.rs
index 41e62116f..ab8e4c70e 100644
--- a/crates/parser/src/lib.rs
+++ b/crates/parser/src/lib.rs
@@ -99,6 +99,8 @@ pub enum FragmentKind {
     // FIXME: use separate fragment kinds for macro inputs and outputs?
     Items,
     Statements,
+
+    Attr,
 }
 
 pub fn parse_fragment(
@@ -118,6 +120,7 @@ pub fn parse_fragment(
         FragmentKind::Statement => grammar::fragments::stmt,
         FragmentKind::Items => grammar::fragments::macro_items,
         FragmentKind::Statements => grammar::fragments::macro_stmts,
+        FragmentKind::Attr => grammar::fragments::attr,
     };
     parse_from_tokens(token_source, tree_sink, parser)
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index af226c109..66f8bee99 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -9,7 +9,7 @@ use std::{
 
 use ide::{
     CompletionResolveCapability, FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData,
-    NavigationTarget, Query, RangeInfo, Runnable, RunnableKind, SearchScope, TextEdit,
+    NavigationTarget, Query, RangeInfo, Runnable, RunnableKind, SearchScope, SymbolKind, TextEdit,
 };
 use itertools::Itertools;
 use lsp_server::ErrorCode;
@@ -27,7 +27,7 @@ use project_model::TargetKind;
 use serde::{Deserialize, Serialize};
 use serde_json::to_value;
 use stdx::{format_to, split_once};
-use syntax::{algo, ast, AstNode, SyntaxKind, TextRange, TextSize};
+use syntax::{algo, ast, AstNode, TextRange, TextSize};
 
 use crate::{
     cargo_target_spec::CargoTargetSpec,
@@ -385,7 +385,10 @@ pub(crate) fn handle_workspace_symbol(
             #[allow(deprecated)]
             let info = SymbolInformation {
                 name: nav.name.to_string(),
-                kind: to_proto::symbol_kind(nav.kind),
+                kind: nav
+                    .kind
+                    .map(to_proto::symbol_kind)
+                    .unwrap_or(lsp_types::SymbolKind::Variable),
                 tags: None,
                 location: to_proto::location_from_nav(snap, nav)?,
                 container_name,
@@ -1037,10 +1040,10 @@ pub(crate) fn handle_code_lens(
                 .filter(|it| {
                     matches!(
                         it.kind,
-                        SyntaxKind::TRAIT
-                            | SyntaxKind::STRUCT
-                            | SyntaxKind::ENUM
-                            | SyntaxKind::UNION
+                        SymbolKind::Trait
+                            | SymbolKind::Struct
+                            | SymbolKind::Enum
+                            | SymbolKind::Union
                     )
                 })
                 .map(|it| {
@@ -1263,7 +1266,7 @@ pub(crate) fn handle_call_hierarchy_prepare(
     let RangeInfo { range: _, info: navs } = nav_info;
     let res = navs
         .into_iter()
-        .filter(|it| it.kind == SyntaxKind::FN)
+        .filter(|it| it.kind == Some(SymbolKind::Function))
         .map(|it| to_proto::call_hierarchy_item(&snap, it))
         .collect::<Result<Vec<_>>>()?;
 
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 72f77a016..e0561b5a7 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -5,14 +5,13 @@ use std::{
 };
 
 use ide::{
-    Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation,
-    FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag, HighlightedRange,
-    Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget,
-    ReferenceAccess, ResolvedAssist, Runnable, Severity, SourceChange, SourceFileEdit, TextEdit,
+    Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
+    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag,
+    HighlightedRange, Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup,
+    NavigationTarget, ReferenceAccess, ResolvedAssist, Runnable, Severity, SourceChange,
+    SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
 };
-use ide_db::base_db::{FileId, FileRange};
 use itertools::Itertools;
-use syntax::{SyntaxKind, TextRange, TextSize};
 
 use crate::{
     cargo_target_spec::CargoTargetSpec, global_state::GlobalStateSnapshot,
@@ -30,21 +29,25 @@ pub(crate) fn range(line_index: &LineIndex, range: TextRange) -> lsp_types::Rang
     lsp_types::Range::new(start, end)
 }
 
-pub(crate) fn symbol_kind(syntax_kind: SyntaxKind) -> lsp_types::SymbolKind {
-    match syntax_kind {
-        SyntaxKind::FN => lsp_types::SymbolKind::Function,
-        SyntaxKind::STRUCT => lsp_types::SymbolKind::Struct,
-        SyntaxKind::ENUM => lsp_types::SymbolKind::Enum,
-        SyntaxKind::VARIANT => lsp_types::SymbolKind::EnumMember,
-        SyntaxKind::TRAIT => lsp_types::SymbolKind::Interface,
-        SyntaxKind::MACRO_CALL => lsp_types::SymbolKind::Function,
-        SyntaxKind::MODULE => lsp_types::SymbolKind::Module,
-        SyntaxKind::TYPE_ALIAS => lsp_types::SymbolKind::TypeParameter,
-        SyntaxKind::RECORD_FIELD => lsp_types::SymbolKind::Field,
-        SyntaxKind::STATIC => lsp_types::SymbolKind::Constant,
-        SyntaxKind::CONST => lsp_types::SymbolKind::Constant,
-        SyntaxKind::IMPL => lsp_types::SymbolKind::Object,
-        _ => lsp_types::SymbolKind::Variable,
+pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
+    match symbol_kind {
+        SymbolKind::Function => lsp_types::SymbolKind::Function,
+        SymbolKind::Struct => lsp_types::SymbolKind::Struct,
+        SymbolKind::Enum => lsp_types::SymbolKind::Enum,
+        SymbolKind::Variant => lsp_types::SymbolKind::EnumMember,
+        SymbolKind::Trait => lsp_types::SymbolKind::Interface,
+        SymbolKind::Macro => lsp_types::SymbolKind::Function,
+        SymbolKind::Module => lsp_types::SymbolKind::Module,
+        SymbolKind::TypeAlias | SymbolKind::TypeParam => lsp_types::SymbolKind::TypeParameter,
+        SymbolKind::Field => lsp_types::SymbolKind::Field,
+        SymbolKind::Static => lsp_types::SymbolKind::Constant,
+        SymbolKind::Const => lsp_types::SymbolKind::Constant,
+        SymbolKind::Impl => lsp_types::SymbolKind::Object,
+        SymbolKind::Local
+        | SymbolKind::SelfParam
+        | SymbolKind::LifetimeParam
+        | SymbolKind::ValueParam => lsp_types::SymbolKind::Variable,
+        SymbolKind::Union => lsp_types::SymbolKind::Struct,
     }
 }
 
@@ -369,34 +372,41 @@ fn semantic_token_type_and_modifiers(
 ) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) {
     let mut mods = semantic_tokens::ModifierSet::default();
     let type_ = match highlight.tag {
-        HighlightTag::Struct => lsp_types::SemanticTokenType::STRUCT,
-        HighlightTag::Enum => lsp_types::SemanticTokenType::ENUM,
-        HighlightTag::Union => semantic_tokens::UNION,
-        HighlightTag::TypeAlias => semantic_tokens::TYPE_ALIAS,
-        HighlightTag::Trait => lsp_types::SemanticTokenType::INTERFACE,
+        HighlightTag::Symbol(symbol) => match symbol {
+            SymbolKind::Module => lsp_types::SemanticTokenType::NAMESPACE,
+            SymbolKind::Impl => lsp_types::SemanticTokenType::TYPE,
+            SymbolKind::Field => lsp_types::SemanticTokenType::PROPERTY,
+            SymbolKind::TypeParam => lsp_types::SemanticTokenType::TYPE_PARAMETER,
+            SymbolKind::LifetimeParam => semantic_tokens::LIFETIME,
+            SymbolKind::ValueParam => lsp_types::SemanticTokenType::PARAMETER,
+            SymbolKind::SelfParam => semantic_tokens::SELF_KEYWORD,
+            SymbolKind::Local => lsp_types::SemanticTokenType::VARIABLE,
+            SymbolKind::Function => {
+                if highlight.modifiers.contains(HighlightModifier::Associated) {
+                    lsp_types::SemanticTokenType::METHOD
+                } else {
+                    lsp_types::SemanticTokenType::FUNCTION
+                }
+            }
+            SymbolKind::Const => {
+                mods |= semantic_tokens::CONSTANT;
+                mods |= lsp_types::SemanticTokenModifier::STATIC;
+                lsp_types::SemanticTokenType::VARIABLE
+            }
+            SymbolKind::Static => {
+                mods |= lsp_types::SemanticTokenModifier::STATIC;
+                lsp_types::SemanticTokenType::VARIABLE
+            }
+            SymbolKind::Struct => lsp_types::SemanticTokenType::STRUCT,
+            SymbolKind::Enum => lsp_types::SemanticTokenType::ENUM,
+            SymbolKind::Variant => lsp_types::SemanticTokenType::ENUM_MEMBER,
+            SymbolKind::Union => semantic_tokens::UNION,
+            SymbolKind::TypeAlias => semantic_tokens::TYPE_ALIAS,
+            SymbolKind::Trait => lsp_types::SemanticTokenType::INTERFACE,
+            SymbolKind::Macro => lsp_types::SemanticTokenType::MACRO,
+        },
         HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
-        HighlightTag::SelfKeyword => semantic_tokens::SELF_KEYWORD,
-        HighlightTag::SelfType => lsp_types::SemanticTokenType::TYPE,
-        HighlightTag::Field => lsp_types::SemanticTokenType::PROPERTY,
-        HighlightTag::Function => lsp_types::SemanticTokenType::FUNCTION,
-        HighlightTag::Generic => semantic_tokens::GENERIC,
-        HighlightTag::Module => lsp_types::SemanticTokenType::NAMESPACE,
-        HighlightTag::Method => lsp_types::SemanticTokenType::METHOD,
-        HighlightTag::Constant => {
-            mods |= semantic_tokens::CONSTANT;
-            mods |= lsp_types::SemanticTokenModifier::STATIC;
-            lsp_types::SemanticTokenType::VARIABLE
-        }
-        HighlightTag::Static => {
-            mods |= lsp_types::SemanticTokenModifier::STATIC;
-            lsp_types::SemanticTokenType::VARIABLE
-        }
-        HighlightTag::EnumVariant => lsp_types::SemanticTokenType::ENUM_MEMBER,
-        HighlightTag::Macro => lsp_types::SemanticTokenType::MACRO,
-        HighlightTag::ValueParam => lsp_types::SemanticTokenType::PARAMETER,
-        HighlightTag::Local => lsp_types::SemanticTokenType::VARIABLE,
-        HighlightTag::TypeParam => lsp_types::SemanticTokenType::TYPE_PARAMETER,
-        HighlightTag::Lifetime => semantic_tokens::LIFETIME,
+        HighlightTag::Dummy => semantic_tokens::GENERIC,
         HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => {
             lsp_types::SemanticTokenType::NUMBER
         }
@@ -426,6 +436,7 @@ fn semantic_token_type_and_modifiers(
             HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
             HighlightModifier::Callable => semantic_tokens::CALLABLE,
             HighlightModifier::Static => lsp_types::SemanticTokenModifier::STATIC,
+            HighlightModifier::Associated => continue,
         };
         mods |= modifier;
     }
@@ -719,7 +730,7 @@ pub(crate) fn call_hierarchy_item(
 ) -> Result<lsp_types::CallHierarchyItem> {
     let name = target.name.to_string();
     let detail = target.description.clone();
-    let kind = symbol_kind(target.kind);
+    let kind = target.kind.map(symbol_kind).unwrap_or(lsp_types::SymbolKind::Function);
     let (uri, range, selection_range) = location_info(snap, target)?;
     Ok(lsp_types::CallHierarchyItem {
         name,
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 16b079c42..ba7e5d2fb 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -20,6 +20,9 @@ pub fn name_ref(text: &str) -> ast::NameRef {
 pub fn ty(text: &str) -> ast::Type {
     ast_from_text(&format!("impl {} for D {{}};", text))
 }
+pub fn ty_unit() -> ast::Type {
+    ty("()")
+}
 
 pub fn assoc_item_list() -> ast::AssocItemList {
     ast_from_text("impl C for D {};")
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index e753b11bb..4d272f367 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -205,6 +205,13 @@ impl ast::Type {
     }
 }
 
+impl ast::Attr {
+    /// Returns `text`, parsed as an attribute, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, parser::FragmentKind::Attr)
+    }
+}
+
 /// Matches a `SyntaxNode` against an `ast` type.
 ///
 /// # Example:
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 2f3dde8ac..191960960 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -132,6 +132,7 @@ async function tryActivate(context: vscode.ExtensionContext) {
     ctx.pushCleanup(activateTaskProvider(workspaceFolder, ctx.config));
 
     activateInlayHints(ctx);
+    warnAboutRustLangExtensionConflict();
 
     vscode.workspace.onDidChangeConfiguration(
         _ => ctx?.client?.sendNotification('workspace/didChangeConfiguration', { settings: "" }),
@@ -399,3 +400,13 @@ async function queryForGithubToken(state: PersistentState): Promise<void> {
         await state.updateGithubToken(newToken);
     }
 }
+
+function warnAboutRustLangExtensionConflict() {
+    const rustLangExt = vscode.extensions.getExtension("rust-lang.rust");
+    if (rustLangExt !== undefined) {
+        vscode.window.showWarningMessage(
+            "You have both rust-analyzer (matklad.rust-analyzer) and Rust (rust-lang.rust) " +
+            "plugins enabled. These are known to conflict and cause various functions of " +
+            "both plugins to not work correctly. You should disable one of them.", "Got it");
+    };
+}