83 files changed, 1383 insertions, 656 deletions
diff --git a/crates/assists/src/handlers/add_lifetime_to_type.rs b/crates/assists/src/handlers/add_lifetime_to_type.rs
new file mode 100644
index 000000000..c1603e972
--- /dev/null
+++ b/crates/assists/src/handlers/add_lifetime_to_type.rs
@@ -0,0 +1,228 @@
+use ast::FieldList;
+use syntax::ast::{self, AstNode, GenericParamsOwner, NameOwner, RefType, Type};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: add_lifetime_to_type
+//
+// Adds a new lifetime to a struct, enum or union.
+//
+// ```
+// struct Point {
+//     x: &$0u32,
+//     y: u32,
+// }
+// ```
+// ->
+// ```
+// struct Point<'a> {
+//     x: &'a u32,
+//     y: u32,
+// }
+// ```
+pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let ref_type_focused = ctx.find_node_at_offset::<ast::RefType>()?;
+    if ref_type_focused.lifetime().is_some() {
+        return None;
+    }
+    let node = ctx.find_node_at_offset::<ast::AdtDef>()?;
+    let has_lifetime = node
+        .generic_param_list()
+        .map(|gen_list| gen_list.lifetime_params().count() > 0)
+        .unwrap_or_default();
+    if has_lifetime {
+        return None;
+    }
+    let ref_types = fetch_borrowed_types(&node)?;
+    let target = node.syntax().text_range();
+    acc.add(
+        AssistId("add_lifetime_to_type", AssistKind::Generate),
+        "Add lifetime`",
+        target,
+        |builder| {
+            match node.generic_param_list() {
+                Some(gen_param) => {
+                    if let Some(left_angle) = gen_param.l_angle_token() {
+                        builder.insert(left_angle.text_range().end(), "'a, ");
+                    }
+                }
+                None => {
+                    if let Some(name) = node.name() {
+                        builder.insert(name.syntax().text_range().end(), "<'a>");
+                    }
+                }
+            }
+            for ref_type in ref_types {
+                if let Some(amp_token) = ref_type.amp_token() {
+                    builder.insert(amp_token.text_range().end(), "'a ");
+                }
+            }
+        },
+    )
+}
+fn fetch_borrowed_types(node: &ast::AdtDef) -> Option<Vec<RefType>> {
+    let ref_types: Vec<RefType> = match node {
+        ast::AdtDef::Enum(enum_) => {
+            let variant_list = enum_.variant_list()?;
+            variant_list
+                .variants()
+                .filter_map(|variant| {
+                    let field_list = variant.field_list()?;
+                    find_ref_types_from_field_list(&field_list)
+                })
+                .flatten()
+                .collect()
+        }
+        ast::AdtDef::Struct(strukt) => {
+            let field_list = strukt.field_list()?;
+            find_ref_types_from_field_list(&field_list)?
+        }
+        ast::AdtDef::Union(un) => {
+            let record_field_list = un.record_field_list()?;
+            record_field_list
+                .fields()
+                .filter_map(|r_field| {
+                    if let Type::RefType(ref_type) = r_field.ty()? {
+                        if ref_type.lifetime().is_none() {
+                            return Some(ref_type);
+                        }
+                    }
+                    None
+                })
+                .collect()
+        }
+    };
+    if ref_types.is_empty() {
+        None
+    } else {
+        Some(ref_types)
+    }
+}
+fn find_ref_types_from_field_list(field_list: &FieldList) -> Option<Vec<RefType>> {
+    let ref_types: Vec<RefType> = match field_list {
+        ast::FieldList::RecordFieldList(record_list) => record_list
+            .fields()
+            .filter_map(|f| {
+                if let Type::RefType(ref_type) = f.ty()? {
+                    if ref_type.lifetime().is_none() {
+                        return Some(ref_type);
+                    }
+                }
+                None
+            })
+            .collect(),
+        ast::FieldList::TupleFieldList(tuple_field_list) => tuple_field_list
+            .fields()
+            .filter_map(|f| {
+                if let Type::RefType(ref_type) = f.ty()? {
+                    if ref_type.lifetime().is_none() {
+                        return Some(ref_type);
+                    }
+                }
+                None
+            })
+            .collect(),
+    };
+    if ref_types.is_empty() {
+        None
+    } else {
+        Some(ref_types)
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn add_lifetime_to_struct() {
+        check_assist(
+            add_lifetime_to_type,
+            "struct Foo { a: &$0i32 }",
+            "struct Foo<'a> { a: &'a i32 }",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "struct Foo { a: &$0i32, b: &usize }",
+            "struct Foo<'a> { a: &'a i32, b: &'a usize }",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "struct Foo { a: &$0i32, b: usize }",
+            "struct Foo<'a> { a: &'a i32, b: usize }",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "struct Foo<T> { a: &$0T, b: usize }",
+            "struct Foo<'a, T> { a: &'a T, b: usize }",
+        );
+        check_assist_not_applicable(add_lifetime_to_type, "struct Foo<'a> { a: &$0'a i32 }");
+        check_assist_not_applicable(add_lifetime_to_type, "struct Foo { a: &'a$0 i32 }");
+    }
+    #[test]
+    fn add_lifetime_to_enum() {
+        check_assist(
+            add_lifetime_to_type,
+            "enum Foo { Bar { a: i32 }, Other, Tuple(u32, &$0u32)}",
+            "enum Foo<'a> { Bar { a: i32 }, Other, Tuple(u32, &'a u32)}",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "enum Foo { Bar { a: &$0i32 }}",
+            "enum Foo<'a> { Bar { a: &'a i32 }}",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "enum Foo<T> { Bar { a: &$0i32, b: &T }}",
+            "enum Foo<'a, T> { Bar { a: &'a i32, b: &'a T }}",
+        );
+        check_assist_not_applicable(add_lifetime_to_type, "enum Foo<'a> { Bar { a: &$0'a i32 }}");
+        check_assist_not_applicable(add_lifetime_to_type, "enum Foo { Bar, $0Misc }");
+    }
+    #[test]
+    fn add_lifetime_to_union() {
+        check_assist(
+            add_lifetime_to_type,
+            "union Foo { a: &$0i32 }",
+            "union Foo<'a> { a: &'a i32 }",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "union Foo { a: &$0i32, b: &usize }",
+            "union Foo<'a> { a: &'a i32, b: &'a usize }",
+        );
+        check_assist(
+            add_lifetime_to_type,
+            "union Foo<T> { a: &$0T, b: usize }",
+            "union Foo<'a, T> { a: &'a T, b: usize }",
+        );
+        check_assist_not_applicable(add_lifetime_to_type, "struct Foo<'a> { a: &'a $0i32 }");
+    }
+}
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index da47187e4..7663d211d 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -8,7 +8,7 @@ use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use test_utils::mark;
 use crate::{
-    utils::{render_snippet, Cursor},
+    utils::{does_pat_match_variant, render_snippet, Cursor},
    AssistContext, AssistId, AssistKind, Assists,
 };
@@ -147,25 +147,6 @@ fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
    })
 }
-fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
-    let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
-    let pat_head = match pat {
-        Pat::IdentPat(bind_pat) => {
-            if let Some(p) = bind_pat.pat() {
-                first_node_text(&p)
-            } else {
-                return false;
-            }
-        }
-        pat => first_node_text(pat),
-    };
-    let var_head = first_node_text(var);
-    pat_head == var_head
-}
 fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
    sema.type_of_expr(&expr)?.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
        Some(Adt::Enum(e)) => Some(e),
diff --git a/crates/assists/src/handlers/replace_if_let_with_match.rs b/crates/assists/src/handlers/replace_if_let_with_match.rs
index aee3397ab..aee880625 100644
--- a/crates/assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/assists/src/handlers/replace_if_let_with_match.rs
@@ -10,7 +10,10 @@ use syntax::{
    AstNode,
 };
-use crate::{utils::unwrap_trivial_block, AssistContext, AssistId, AssistKind, Assists};
+use crate::{
+    utils::{does_pat_match_variant, unwrap_trivial_block},
+    AssistContext, AssistId, AssistKind, Assists,
+};
 // Assist: replace_if_let_with_match
 //
@@ -66,7 +69,13 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext)
                        .sema
                        .type_of_pat(&pat)
                        .and_then(|ty| TryEnum::from_ty(&ctx.sema, &ty))
-                        .map(|it| it.sad_pattern())
+                        .map(|it| {
+                            if does_pat_match_variant(&pat, &it.sad_pattern()) {
+                                it.happy_pattern()
+                            } else {
+                                it.sad_pattern()
+                            }
+                        })
                        .unwrap_or_else(|| make::wildcard_pat().into());
                    let else_expr = unwrap_trivial_block(else_block);
                    make::match_arm(vec![pattern], else_expr)
@@ -279,6 +288,36 @@ fn foo(x: Option<i32>) {
    }
    #[test]
+    fn special_case_inverted_option() {
+        check_assist(
+            replace_if_let_with_match,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn foo(x: Option<i32>) {
+    $0if let None = x {
+        println!("none")
+    } else {
+        println!("some")
+    }
+}
+           "#,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn foo(x: Option<i32>) {
+    match x {
+        None => println!("none"),
+        Some(_) => println!("some"),
+    }
+}
+           "#,
+        );
+    }
+    #[test]
    fn special_case_result() {
        check_assist(
            replace_if_let_with_match,
@@ -309,6 +348,36 @@ fn foo(x: Result<i32, ()>) {
    }
    #[test]
+    fn special_case_inverted_result() {
+        check_assist(
+            replace_if_let_with_match,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
+fn foo(x: Result<i32, ()>) {
+    $0if let Err(x) = x {
+        println!("{}", x)
+    } else {
+        println!("ok")
+    }
+}
+           "#,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
+fn foo(x: Result<i32, ()>) {
+    match x {
+        Err(x) => println!("{}", x),
+        Ok(_) => println!("ok"),
+    }
+}
+           "#,
+        );
+    }
+    #[test]
    fn nested_indent() {
        check_assist(
            replace_if_let_with_match,
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 14178a651..559b9651e 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -108,6 +108,7 @@ mod handlers {
    pub(crate) type Handler = fn(&mut Assists, &AssistContext) -> Option<()>;
    mod add_explicit_type;
+    mod add_lifetime_to_type;
    mod add_missing_impl_members;
    mod add_turbo_fish;
    mod apply_demorgan;
@@ -164,6 +165,7 @@ mod handlers {
        &[
            // These are alphabetic for the foolish consistency
            add_explicit_type::add_explicit_type,
+            add_lifetime_to_type::add_lifetime_to_type,
            add_turbo_fish::add_turbo_fish,
            apply_demorgan::apply_demorgan,
            auto_import::auto_import,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index d48d063b4..9aa807f10 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -104,6 +104,25 @@ impl Trait<u32> for () {
 }
 #[test]
+fn doctest_add_lifetime_to_type() {
+    check_doc_test(
+        "add_lifetime_to_type",
+        r#####"
+struct Point {
+    x: &$0u32,
+    y: u32,
+}
+"#####,
+        r#####"
+struct Point<'a> {
+    x: &'a u32,
+    y: u32,
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_add_turbo_fish() {
    check_doc_test(
        "add_turbo_fish",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 44c35bafa..4e762e18b 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -248,3 +248,22 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
 pub(crate) fn next_prev() -> impl Iterator<Item = Direction> {
    [Direction::Next, Direction::Prev].iter().copied()
 }
+pub(crate) fn does_pat_match_variant(pat: &ast::Pat, var: &ast::Pat) -> bool {
+    let first_node_text = |pat: &ast::Pat| pat.syntax().first_child().map(|node| node.text());
+    let pat_head = match pat {
+        ast::Pat::IdentPat(bind_pat) => {
+            if let Some(p) = bind_pat.pat() {
+                first_node_text(&p)
+            } else {
+                return pat.syntax().text() == var.syntax().text();
+            }
+        }
+        pat => first_node_text(pat),
+    };
+    let var_head = first_node_text(var);
+    pat_head == var_head
+}
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
index d04eef65a..0880a3830 100644
--- a/crates/completion/src/completions/dot.rs
+++ b/crates/completion/src/completions/dot.rs
@@ -83,7 +83,7 @@ fn foo(s: S) { s.$0 }
 "#,
            expect![[r#"
                fd foo   u32
-                me bar() fn bar(&self)
+                me bar() -> ()
            "#]],
        );
    }
@@ -99,7 +99,7 @@ impl S {
 "#,
            expect![[r#"
                fd the_field (u32,)
-                me foo()     fn foo(self)
+                me foo()     -> ()
            "#]],
        )
    }
@@ -115,7 +115,7 @@ impl A {
 "#,
            expect![[r#"
                fd the_field (u32, i32)
-                me foo()     fn foo(&self)
+                me foo()     -> ()
            "#]],
        )
    }
@@ -165,7 +165,7 @@ mod m {
 fn foo(a: A) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() pub(crate) fn the_method(&self)
+                me the_method() -> ()
            "#]],
        );
    }
@@ -198,7 +198,7 @@ impl A<i32> {
 fn foo(a: A<u32>) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() fn the_method(&self)
+                me the_method() -> ()
            "#]],
        )
    }
@@ -213,7 +213,7 @@ impl Trait for A {}
 fn foo(a: A) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() fn the_method(&self)
+                me the_method() -> ()
            "#]],
        );
    }
@@ -228,7 +228,7 @@ impl<T> Trait for T {}
 fn foo(a: &A) { a.$0 }
 ",
            expect![[r#"
-                me the_method() fn the_method(&self)
+                me the_method() -> ()
            "#]],
        );
    }
@@ -246,7 +246,7 @@ impl Trait for A {}
 fn foo(a: A) { a.$0 }
 ",
            expect![[r#"
-                me the_method() fn the_method(&self)
+                me the_method() -> ()
            "#]],
        );
    }
@@ -300,7 +300,7 @@ impl T {
 }
 "#,
            expect![[r#"
-                me blah() pub fn blah(&self)
+                me blah() -> ()
            "#]],
        );
    }
@@ -409,7 +409,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                me the_method() pub fn the_method(&self)
+                me the_method() -> ()
            "#]],
        );
    }
@@ -424,7 +424,7 @@ macro_rules! make_s { () => { S }; }
 fn main() { make_s!().f$0; }
 "#,
            expect![[r#"
-                me foo() fn foo(&self)
+                me foo() -> ()
            "#]],
        )
    }
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index dc0b38a16..6591127b1 100644
--- a/crates/completion/src/completions/flyimport.rs
+++ b/crates/completion/src/completions/flyimport.rs
@@ -366,8 +366,8 @@ fn main() {
        check(
            fixture,
            expect![[r#"
-            fn weird_function() (dep::test_mod::TestTrait) fn weird_function()
+                fn weird_function() (dep::test_mod::TestTrait) -> ()
-        "#]],
+            "#]],
        );
        check_edit(
@@ -459,8 +459,8 @@ fn main() {
        check(
            fixture,
            expect![[r#"
-            me random_method() (dep::test_mod::TestTrait) fn random_method(&self)
+                me random_method() (dep::test_mod::TestTrait) -> ()
-        "#]],
+            "#]],
        );
        check_edit(
@@ -629,8 +629,8 @@ fn main() {
 }
        "#,
            expect![[r#"
-                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self) DEPRECATED
+                me random_method() (dep::test_mod::TestTrait) -> () DEPRECATED
-                "#]],
+            "#]],
        );
        check(
@@ -660,8 +660,8 @@ fn main() {
 "#,
            expect![[r#"
                ct SPECIAL_CONST (dep::test_mod::TestTrait) DEPRECATED
-                fn weird_function() (dep::test_mod::TestTrait) fn weird_function() DEPRECATED
+                fn weird_function() (dep::test_mod::TestTrait) -> () DEPRECATED
-        "#]],
+            "#]],
        );
    }
 }
diff --git a/crates/completion/src/completions/fn_param.rs b/crates/completion/src/completions/fn_param.rs
index 5505c3559..38e33a93e 100644
--- a/crates/completion/src/completions/fn_param.rs
+++ b/crates/completion/src/completions/fn_param.rs
@@ -6,7 +6,7 @@ use syntax::{
    match_ast, AstNode,
 };
-use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};
+use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 /// Complete repeated parameters, both name and type. For example, if all
 /// functions in a file have a `spam: &mut Spam` parameter, a completion with
@@ -58,7 +58,7 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
        })
        .for_each(|(label, lookup)| {
            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
-                .kind(crate::CompletionItemKind::Binding)
+                .kind(CompletionItemKind::Binding)
                .lookup_by(lookup)
                .add_to(acc)
        });
diff --git a/crates/completion/src/completions/mod_.rs b/crates/completion/src/completions/mod_.rs
index 00e951ca9..352fc7c77 100644
--- a/crates/completion/src/completions/mod_.rs
+++ b/crates/completion/src/completions/mod_.rs
@@ -3,11 +3,13 @@
 use std::iter;
 use hir::{Module, ModuleSource};
-use ide_db::base_db::{SourceDatabaseExt, VfsPath};
+use ide_db::{
-use ide_db::RootDatabase;
+    base_db::{SourceDatabaseExt, VfsPath},
+    RootDatabase, SymbolKind,
+};
 use rustc_hash::FxHashSet;
-use crate::{CompletionItem, CompletionItemKind};
+use crate::CompletionItem;
 use crate::{context::CompletionContext, item::CompletionKind, Completions};
@@ -79,7 +81,7 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
                label.push(';');
            }
            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
-                .kind(CompletionItemKind::Module)
+                .kind(SymbolKind::Module)
                .add_to(acc)
        });
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
index 33df26761..bbeaab496 100644
--- a/crates/completion/src/completions/qualified_path.rs
+++ b/crates/completion/src/completions/qualified_path.rs
@@ -359,8 +359,8 @@ impl S {
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn a()  fn a()
+                fn a()  -> ()
-                me b(…) fn b(&self)
+                me b(…) -> ()
                ct C    const C: i32 = 42;
                ta T    type T = i32;
            "#]],
@@ -387,7 +387,7 @@ mod m {
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn public_method() pub(crate) fn public_method()
+                fn public_method() -> ()
                ct PUBLIC_CONST    pub(crate) const PUBLIC_CONST: u32 = 1;
                ta PublicType      pub(crate) type PublicType = u32;
            "#]],
@@ -404,7 +404,7 @@ impl E { fn m() { } }
 fn foo() { let _ = E::$0 }
        "#,
            expect![[r#"
-                fn m() fn m()
+                fn m() -> ()
            "#]],
        );
    }
@@ -419,7 +419,7 @@ impl U { fn m() { } }
 fn foo() { let _ = U::$0 }
 "#,
            expect![[r#"
-                fn m() fn m()
+                fn m() -> ()
            "#]],
        );
    }
@@ -449,7 +449,7 @@ trait Trait { fn m(); }
 fn foo() { let _ = Trait::$0 }
 "#,
            expect![[r#"
-                fn m() fn m()
+                fn m() -> ()
            "#]],
        );
    }
@@ -466,7 +466,7 @@ impl Trait for S {}
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn m() fn m()
+                fn m() -> ()
            "#]],
        );
    }
@@ -483,7 +483,7 @@ impl Trait for S {}
 fn foo() { let _ = <S as Trait>::$0 }
 "#,
            expect![[r#"
-                fn m() fn m()
+                fn m() -> ()
            "#]],
        );
    }
@@ -512,11 +512,11 @@ fn foo<T: Sub>() { T::$0 }
                ta SubTy        type SubTy;
                ta Ty           type Ty;
                ct C2           const C2: ();
-                fn subfunc()    fn subfunc()
+                fn subfunc()    -> ()
-                me submethod(…) fn submethod(&self)
+                me submethod(…) -> ()
                ct CONST        const CONST: u8;
-                fn func()       fn func()
+                fn func()       -> ()
-                me method(…)    fn method(&self)
+                me method(…)    -> ()
            "#]],
        );
    }
@@ -552,11 +552,11 @@ impl<T> Sub for Wrap<T> {
                ta SubTy        type SubTy;
                ta Ty           type Ty;
                ct CONST        const CONST: u8 = 0;
-                fn func()       fn func()
+                fn func()       -> ()
-                me method(…)    fn method(&self)
+                me method(…)    -> ()
                ct C2           const C2: () = ();
-                fn subfunc()    fn subfunc()
+                fn subfunc()    -> ()
-                me submethod(…) fn submethod(&self)
+                me submethod(…) -> ()
            "#]],
        );
    }
@@ -573,8 +573,8 @@ impl T { fn bar() {} }
 fn main() { T::$0; }
 "#,
            expect![[r#"
-                fn foo() fn foo()
+                fn foo() -> ()
-                fn bar() fn bar()
+                fn bar() -> ()
            "#]],
        );
    }
@@ -589,7 +589,7 @@ macro_rules! foo { () => {} }
 fn main() { let _ = crate::$0 }
        "#,
            expect![[r##"
-                fn main()  fn main()
+                fn main()  -> ()
                ma foo!(…) #[macro_export] macro_rules! foo
            "##]],
        );
@@ -633,7 +633,7 @@ mod p {
 "#,
            expect![[r#"
                ct RIGHT_CONST
-                fn right_fn()  fn wrong_fn()
+                fn right_fn()  -> ()
                st RightType
            "#]],
        );
@@ -680,8 +680,8 @@ fn main() { m!(self::f$0); }
 fn foo() {}
 "#,
            expect![[r#"
-                fn main() fn main()
+                fn main() -> ()
-                fn foo()  fn foo()
+                fn foo()  -> ()
            "#]],
        );
    }
@@ -699,7 +699,7 @@ mod m {
 "#,
            expect![[r#"
                md z
-                fn z() pub fn z()
+                fn z() -> ()
            "#]],
        );
    }
@@ -719,7 +719,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                fn new() pub fn new() -> HashMap<K, V, RandomState>
+                fn new() -> HashMap<K, V, RandomState>
            "#]],
        );
    }
@@ -752,8 +752,8 @@ fn main() {
 }
 "#,
            expect![[r#"
-                fn main() fn main()
+                fn main() -> ()
-                fn foo(…) fn foo(a: i32, b: i32)
+                fn foo(…) -> ()
            "#]],
        );
    }
@@ -776,7 +776,7 @@ impl Foo {
            expect![[r#"
                ev Bar    ()
                ev Baz    ()
-                me foo(…) fn foo(self)
+                me foo(…) -> ()
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index bb6354ded..0a7927eb8 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -1,10 +1,8 @@
 //! Complete fields in record literals and patterns.
-use ide_db::helpers::FamousDefs;
+use ide_db::{helpers::FamousDefs, SymbolKind};
 use syntax::ast::Expr;
-use crate::{
+use crate::{item::CompletionKind, CompletionContext, CompletionItem, Completions};
-    item::CompletionKind, CompletionContext, CompletionItem, CompletionItemKind, Completions,
-};
 pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
    let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
@@ -31,7 +29,7 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
                        "..Default::default()",
                    )
                    .insert_text(completion_text)
-                    .kind(CompletionItemKind::Field)
+                    .kind(SymbolKind::Field)
                    .build(),
                );
            }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index 135ae49dc..b999540b8 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -32,7 +32,7 @@
 //! ```
 use hir::{self, HasAttrs, HasSource};
-use ide_db::traits::get_missing_assoc_items;
+use ide_db::{traits::get_missing_assoc_items, SymbolKind};
 use syntax::{
    ast::{self, edit, Impl},
    display::function_declaration,
@@ -152,7 +152,7 @@ fn add_function_impl(
    let completion_kind = if func.self_param(ctx.db).is_some() {
        CompletionItemKind::Method
    } else {
-        CompletionItemKind::Function
+        CompletionItemKind::SymbolKind(SymbolKind::Function)
    };
    let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
@@ -188,7 +188,7 @@ fn add_type_alias_impl(
    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
        .text_edit(TextEdit::replace(range, snippet))
        .lookup_by(alias_name)
-        .kind(CompletionItemKind::TypeAlias)
+        .kind(SymbolKind::TypeAlias)
        .set_documentation(type_alias.docs(ctx.db))
        .add_to(acc);
 }
@@ -211,7 +211,7 @@ fn add_const_impl(
            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
                .text_edit(TextEdit::replace(range, snippet))
                .lookup_by(const_name)
-                .kind(CompletionItemKind::Const)
+                .kind(SymbolKind::Const)
                .set_documentation(const_.docs(ctx.db))
                .add_to(acc);
        }
@@ -679,11 +679,6 @@ impl Test for () {
    #[test]
    fn complete_without_name() {
        let test = |completion: &str, hint: &str, completed: &str, next_sibling: &str| {
-            println!(
-                "completion='{}', hint='{}', next_sibling='{}'",
-                completion, hint, next_sibling
-            );
            check_edit(
                completion,
                &format!(
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 809e1645a..5d62fab97 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -165,9 +165,9 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                bn y       i32
+                lc y       i32
-                bn x       i32
+                lc x       i32
-                fn quux(…) fn quux(x: i32)
+                fn quux(…) -> ()
            "#]],
        );
    }
@@ -187,9 +187,9 @@ fn quux() {
 }
 "#,
            expect![[r#"
-                bn b      i32
+                lc b      i32
-                bn a
+                lc a
-                fn quux() fn quux()
+                fn quux() -> ()
            "#]],
        );
    }
@@ -203,8 +203,8 @@ fn quux() {
 }
 "#,
            expect![[r#"
-                bn x
+                lc x
-                fn quux() fn quux()
+                fn quux() -> ()
            "#]],
        );
    }
@@ -235,14 +235,14 @@ fn main() {
            r#"fn quux<T>() { $0 }"#,
            expect![[r#"
                tp T
-                fn quux() fn quux<T>()
+                fn quux() -> ()
            "#]],
        );
        check(
            r#"fn quux<const C: usize>() { $0 }"#,
            expect![[r#"
-                tp C
+                cp C
-                fn quux() fn quux<const C: usize>()
+                fn quux() -> ()
            "#]],
        );
    }
@@ -253,7 +253,7 @@ fn main() {
        check(
            r#"fn quux<'a>() { $0 }"#,
            expect![[r#"
-                fn quux() fn quux<'a>()
+                fn quux() -> ()
            "#]],
        );
    }
@@ -263,7 +263,7 @@ fn main() {
        check(
            r#"struct S<T> { x: $0}"#,
            expect![[r#"
-                tp Self
+                sp Self
                tp T
                st S<…>
            "#]],
@@ -275,7 +275,7 @@ fn main() {
        check(
            r#"enum X { Y($0) }"#,
            expect![[r#"
-                tp Self
+                sp Self
                en X
            "#]],
        );
@@ -291,7 +291,7 @@ fn quux() { $0 }
 "#,
            expect![[r#"
                st S
-                fn quux() fn quux()
+                fn quux() -> ()
                en E
            "#]],
        );
@@ -344,7 +344,7 @@ mod m {
 }
 "#,
            expect![[r#"
-                fn quux() fn quux()
+                fn quux() -> ()
                st Bar
            "#]],
        );
@@ -359,7 +359,7 @@ fn x() -> $0
 "#,
            expect![[r#"
                st Foo
-                fn x() fn x()
+                fn x() -> ()
            "#]],
        );
    }
@@ -378,9 +378,9 @@ fn foo() {
 "#,
            // FIXME: should be only one bar here
            expect![[r#"
-                bn bar   i32
+                lc bar   i32
-                bn bar   i32
+                lc bar   i32
-                fn foo() fn foo()
+                fn foo() -> ()
            "#]],
        );
    }
@@ -390,8 +390,8 @@ fn foo() {
        check(
            r#"impl S { fn foo(&self) { $0 } }"#,
            expect![[r#"
-                bn self &{unknown}
+                lc self &{unknown}
-                tp Self
+                sp Self
            "#]],
        );
    }
@@ -410,7 +410,7 @@ use prelude::*;
 mod prelude { struct Option; }
 "#,
            expect![[r#"
-                fn foo()  fn foo()
+                fn foo()  -> ()
                md std
                st Option
            "#]],
@@ -440,7 +440,7 @@ mod macros {
 }
 "#,
            expect![[r##"
-                fn f()        fn f()
+                fn f()        -> ()
                ma concat!(…) #[macro_export] macro_rules! concat
                md std
            "##]],
@@ -467,7 +467,7 @@ use prelude::*;
 mod prelude { struct String; }
 "#,
            expect![[r#"
-                fn foo()  fn foo()
+                fn foo()  -> ()
                md std
                md core
                st String
@@ -498,7 +498,7 @@ fn main() { let v = $0 }
            expect![[r##"
                md m1
                ma baz!(…) #[macro_export] macro_rules! baz
-                fn main()  fn main()
+                fn main()  -> ()
                md m2
                ma bar!(…) macro_rules! bar
                ma foo!(…) macro_rules! foo
@@ -514,7 +514,7 @@ macro_rules! foo { () => {} }
 fn foo() { $0 }
 "#,
            expect![[r#"
-                fn foo()   fn foo()
+                fn foo()   -> ()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -528,7 +528,7 @@ macro_rules! foo { () => {} }
 fn main() { let x: $0 }
 "#,
            expect![[r#"
-                fn main()  fn main()
+                fn main()  -> ()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -542,7 +542,7 @@ macro_rules! foo { () => {} }
 fn main() { $0 }
 "#,
            expect![[r#"
-                fn main()  fn main()
+                fn main()  -> ()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -558,8 +558,8 @@ fn main() {
 }
 "#,
            expect![[r#"
-                fn frobnicate() fn frobnicate()
+                fn frobnicate() -> ()
-                fn main()       fn main()
+                fn main()       -> ()
            "#]],
        );
    }
@@ -575,9 +575,9 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                bn y       i32
+                lc y       i32
-                bn x       i32
+                lc x       i32
-                fn quux(…) fn quux(x: i32)
+                fn quux(…) -> ()
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -594,9 +594,9 @@ fn quux(x: i32) {
 }
 ",
            expect![[r#"
-                bn y       i32
+                lc y       i32
-                bn x       i32
+                lc x       i32
-                fn quux(…) fn quux(x: i32)
+                fn quux(…) -> ()
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -613,9 +613,9 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                bn y       i32
+                lc y       i32
-                bn x       i32
+                lc x       i32
-                fn quux(…) fn quux(x: i32)
+                fn quux(…) -> ()
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -630,7 +630,7 @@ use spam::Quux;
 fn main() { $0 }
 "#,
            expect![[r#"
-                fn main() fn main()
+                fn main() -> ()
                ?? Quux
            "#]],
        );
@@ -708,7 +708,7 @@ fn main() { let foo: Foo = Q$0 }
                ev Foo::Baz  ()
                ev Foo::Quux ()
                en Foo
-                fn main()    fn main()
+                fn main()    -> ()
            "#]],
        )
    }
@@ -723,7 +723,7 @@ fn f() -> m::E { V$0 }
            expect![[r#"
                ev m::E::V ()
                md m
-                fn f()     fn f() -> m::E
+                fn f()     -> E
            "#]],
        )
    }
@@ -750,7 +750,7 @@ struct MyStruct {}
 impl My$0
 "#,
            expect![[r#"
-                tp Self
+                sp Self
                tt MyTrait
                st MyStruct
            "#]],
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index 4147853e7..eeb952ec3 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -3,11 +3,14 @@
 use std::fmt;
 use hir::{Documentation, ModPath, Mutability};
-use ide_db::helpers::{
+use ide_db::{
-    insert_use::{self, ImportScope, MergeBehavior},
+    helpers::{
-    mod_path_to_ast, SnippetCap,
+        insert_use::{self, ImportScope, MergeBehavior},
+        mod_path_to_ast, SnippetCap,
+    },
+    SymbolKind,
 };
-use stdx::assert_never;
+use stdx::{assert_never, impl_from};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
@@ -117,49 +120,50 @@ pub enum CompletionScore {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompletionItemKind {
-    Snippet,
+    SymbolKind(SymbolKind),
-    Keyword,
+    Attribute,
-    Module,
-    Function,
-    BuiltinType,
-    Struct,
-    Enum,
-    EnumVariant,
    Binding,
-    Field,
+    BuiltinType,
-    Static,
+    Keyword,
-    Const,
-    Trait,
-    TypeAlias,
    Method,
-    TypeParam,
+    Snippet,
-    Macro,
-    Attribute,
    UnresolvedReference,
 }
+impl_from!(SymbolKind for CompletionItemKind);
 impl CompletionItemKind {
    #[cfg(test)]
    pub(crate) fn tag(&self) -> &'static str {
        match self {
+            CompletionItemKind::SymbolKind(kind) => match kind {
+                SymbolKind::Const => "ct",
+                SymbolKind::ConstParam => "cp",
+                SymbolKind::Enum => "en",
+                SymbolKind::Field => "fd",
+                SymbolKind::Function => "fn",
+                SymbolKind::Impl => "im",
+                SymbolKind::Label => "lb",
+                SymbolKind::LifetimeParam => "lt",
+                SymbolKind::Local => "lc",
+                SymbolKind::Macro => "ma",
+                SymbolKind::Module => "md",
+                SymbolKind::SelfParam => "sp",
+                SymbolKind::Static => "sc",
+                SymbolKind::Struct => "st",
+                SymbolKind::Trait => "tt",
+                SymbolKind::TypeAlias => "ta",
+                SymbolKind::TypeParam => "tp",
+                SymbolKind::Union => "un",
+                SymbolKind::ValueParam => "vp",
+                SymbolKind::Variant => "ev",
+            },
            CompletionItemKind::Attribute => "at",
            CompletionItemKind::Binding => "bn",
            CompletionItemKind::BuiltinType => "bt",
-            CompletionItemKind::Const => "ct",
-            CompletionItemKind::Enum => "en",
-            CompletionItemKind::EnumVariant => "ev",
-            CompletionItemKind::Field => "fd",
-            CompletionItemKind::Function => "fn",
            CompletionItemKind::Keyword => "kw",
-            CompletionItemKind::Macro => "ma",
            CompletionItemKind::Method => "me",
-            CompletionItemKind::Module => "md",
            CompletionItemKind::Snippet => "sn",
-            CompletionItemKind::Static => "sc",
-            CompletionItemKind::Struct => "st",
-            CompletionItemKind::Trait => "tt",
-            CompletionItemKind::TypeAlias => "ta",
-            CompletionItemKind::TypeParam => "tp",
            CompletionItemKind::UnresolvedReference => "??",
        }
    }
@@ -382,8 +386,8 @@ impl Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.insert_text(snippet)
    }
-    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
+    pub(crate) fn kind(mut self, kind: impl Into<CompletionItemKind>) -> Builder {
-        self.kind = Some(kind);
+        self.kind = Some(kind.into());
        self
    }
    pub(crate) fn text_edit(mut self, edit: TextEdit) -> Builder {
@@ -394,14 +398,13 @@ impl Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.text_edit(edit)
    }
-    #[allow(unused)]
    pub(crate) fn detail(self, detail: impl Into<String>) -> Builder {
        self.set_detail(Some(detail))
    }
    pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
        self.detail = detail.map(Into::into);
        if let Some(detail) = &self.detail {
-            if assert_never!(detail.contains('\n'), "multiline detail: {}", detail) {
+            if assert_never!(detail.contains('\n'), "multiline detail:\n{}", detail) {
                self.detail = Some(detail.splitn(2, '\n').next().unwrap().to_string());
            }
        }
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index 2c4e54524..db8bfbbc3 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -209,25 +209,24 @@ mod tests {
    fn test_completion_detail_from_macro_generated_struct_fn_doc_attr() {
        check_detail_and_documentation(
            r#"
-            //- /lib.rs
+macro_rules! bar {
-            macro_rules! bar {
+    () => {
-                () => {
+        struct Bar;
-                    struct Bar;
+        impl Bar {
-                    impl Bar {
+            #[doc = "Do the foo"]
-                        #[doc = "Do the foo"]
+            fn foo(&self) {}
-                        fn foo(&self) {}
+        }
-                    }
+    }
-                }
+}
-            }
-            bar!();
+bar!();
-            fn foo() {
+fn foo() {
-                let bar = Bar;
+    let bar = Bar;
-                bar.fo$0;
+    bar.fo$0;
-            }
+}
-            "#,
+"#,
-            DetailAndDocumentation { detail: "fn foo(&self)", documentation: "Do the foo" },
+            DetailAndDocumentation { detail: "-> ()", documentation: "Do the foo" },
        );
    }
@@ -235,52 +234,42 @@ mod tests {
    fn test_completion_detail_from_macro_generated_struct_fn_doc_comment() {
        check_detail_and_documentation(
            r#"
-            //- /lib.rs
+macro_rules! bar {
-            macro_rules! bar {
+    () => {
-                () => {
+        struct Bar;
-                    struct Bar;
+        impl Bar {
-                    impl Bar {
+            /// Do the foo
-                        /// Do the foo
+            fn foo(&self) {}
-                        fn foo(&self) {}
+        }
-                    }
+    }
-                }
+}
-            }
-            bar!();
+bar!();
-            fn foo() {
+fn foo() {
-                let bar = Bar;
+    let bar = Bar;
-                bar.fo$0;
+    bar.fo$0;
-            }
+}
-            "#,
+"#,
-            DetailAndDocumentation { detail: "fn foo(&self)", documentation: " Do the foo" },
+            DetailAndDocumentation { detail: "-> ()", documentation: " Do the foo" },
        );
    }
    #[test]
    fn test_no_completions_required() {
        // There must be no hint for 'in' keyword.
-        check_no_completion(
+        check_no_completion(r#"fn foo() { for i i$0 }"#);
-            r#"
-            fn foo() {
-                for i i$0
-            }
-            "#,
-        );
        // After 'in' keyword hints may be spawned.
        check_detail_and_documentation(
            r#"
-            /// Do the foo
+/// Do the foo
-            fn foo() -> &'static str { "foo" }
+fn foo() -> &'static str { "foo" }
-            fn bar() {
+fn bar() {
-                for c in fo$0
+    for c in fo$0
-            }
+}
-            "#,
+"#,
-            DetailAndDocumentation {
+            DetailAndDocumentation { detail: "-> &str", documentation: "Do the foo" },
-                detail: "fn foo() -> &'static str",
-                documentation: "Do the foo",
-            },
        );
    }
 }
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 4f622d28a..e11b881ca 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -13,7 +13,7 @@ mod builder_ext;
 use hir::{
    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
 };
-use ide_db::{helpers::SnippetCap, RootDatabase};
+use ide_db::{helpers::SnippetCap, RootDatabase, SymbolKind};
 use syntax::TextRange;
 use test_utils::mark;
@@ -146,7 +146,7 @@ impl<'a> Render<'a> {
            self.ctx.source_range(),
            name.to_string(),
        )
-        .kind(CompletionItemKind::Field)
+        .kind(SymbolKind::Field)
        .detail(ty.display(self.ctx.db()).to_string())
        .set_documentation(field.docs(self.ctx.db()))
        .set_deprecated(is_deprecated);
@@ -160,7 +160,7 @@ impl<'a> Render<'a> {
    fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), field.to_string())
-            .kind(CompletionItemKind::Field)
+            .kind(SymbolKind::Field)
            .detail(ty.display(self.ctx.db()).to_string())
            .build()
    }
@@ -187,7 +187,7 @@ impl<'a> Render<'a> {
                if self.ctx.completion.is_pat_binding_or_const
                    | self.ctx.completion.is_irrefutable_pat_binding =>
            {
-                CompletionItemKind::EnumVariant
+                CompletionItemKind::SymbolKind(SymbolKind::Variant)
            }
            ScopeDef::ModuleDef(Variant(var)) => {
                let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
@@ -198,20 +198,28 @@ impl<'a> Render<'a> {
                return item;
            }
-            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
+            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::SymbolKind(SymbolKind::Module),
-            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct,
+            ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
-            // FIXME: add CompletionItemKind::Union
+                hir::Adt::Struct(_) => SymbolKind::Struct,
-            ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct,
+                hir::Adt::Union(_) => SymbolKind::Union,
-            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum,
+                hir::Adt::Enum(_) => SymbolKind::Enum,
-            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
+            }),
-            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
+            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
-            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
+            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
-            ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias,
+            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
+            ScopeDef::ModuleDef(TypeAlias(..)) => {
+                CompletionItemKind::SymbolKind(SymbolKind::TypeAlias)
+            }
            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
-            ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam,
+            ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {
-            ScopeDef::Local(..) => CompletionItemKind::Binding,
+                hir::GenericParam::TypeParam(_) => SymbolKind::TypeParam,
-            // (does this need its own kind?)
+                hir::GenericParam::LifetimeParam(_) => SymbolKind::LifetimeParam,
-            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam,
+                hir::GenericParam::ConstParam(_) => SymbolKind::ConstParam,
+            }),
+            ScopeDef::Local(..) => CompletionItemKind::SymbolKind(SymbolKind::Local),
+            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => {
+                CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
+            }
            ScopeDef::Unknown => {
                let item = CompletionItem::new(
                    CompletionKind::Reference,
@@ -400,7 +408,9 @@ fn main() { Foo::Fo$0 }
                        source_range: 54..56,
                        delete: 54..56,
                        insert: "Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        detail: "{ x: i32, y: i32 }",
                    },
                ]
@@ -423,7 +433,9 @@ fn main() { Foo::Fo$0 }
                        source_range: 46..48,
                        delete: 46..48,
                        insert: "Foo($0)",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        lookup: "Foo",
                        detail: "(i32, i32)",
                        trigger_call_info: true,
@@ -448,7 +460,9 @@ fn main() { Foo::Fo$0 }
                        source_range: 35..37,
                        delete: 35..37,
                        insert: "Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        detail: "()",
                    },
                ]
@@ -472,7 +486,9 @@ fn main() { let _: m::Spam = S$0 }
                        source_range: 75..76,
                        delete: 75..76,
                        insert: "Spam::Bar($0)",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        lookup: "Spam::Bar",
                        detail: "(i32)",
                        trigger_call_info: true,
@@ -482,14 +498,18 @@ fn main() { let _: m::Spam = S$0 }
                        source_range: 75..76,
                        delete: 75..76,
                        insert: "m",
-                        kind: Module,
+                        kind: SymbolKind(
+                            Module,
+                        ),
                    },
                    CompletionItem {
                        label: "m::Spam::Foo",
                        source_range: 75..76,
                        delete: 75..76,
                        insert: "m::Spam::Foo",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        lookup: "Spam::Foo",
                        detail: "()",
                    },
@@ -498,9 +518,11 @@ fn main() { let _: m::Spam = S$0 }
                        source_range: 75..76,
                        delete: 75..76,
                        insert: "main()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        lookup: "main",
-                        detail: "fn main()",
+                        detail: "-> ()",
                    },
                ]
            "#]],
@@ -525,18 +547,22 @@ fn main() { som$0 }
                        source_range: 127..130,
                        delete: 127..130,
                        insert: "main()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        lookup: "main",
-                        detail: "fn main()",
+                        detail: "-> ()",
                    },
                    CompletionItem {
                        label: "something_deprecated()",
                        source_range: 127..130,
                        delete: 127..130,
                        insert: "something_deprecated()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        lookup: "something_deprecated",
-                        detail: "fn something_deprecated()",
+                        detail: "-> ()",
                        deprecated: true,
                    },
                    CompletionItem {
@@ -544,9 +570,11 @@ fn main() { som$0 }
                        source_range: 127..130,
                        delete: 127..130,
                        insert: "something_else_deprecated()$0",
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        lookup: "something_else_deprecated",
-                        detail: "fn something_else_deprecated()",
+                        detail: "-> ()",
                        deprecated: true,
                    },
                ]
@@ -565,7 +593,9 @@ fn foo() { A { the$0 } }
                        source_range: 57..60,
                        delete: 57..60,
                        insert: "the_field",
-                        kind: Field,
+                        kind: SymbolKind(
+                            Field,
+                        ),
                        detail: "u32",
                        deprecated: true,
                    },
@@ -595,7 +625,7 @@ impl S {
                        insert: "bar()$0",
                        kind: Method,
                        lookup: "bar",
-                        detail: "fn bar(self)",
+                        detail: "-> ()",
                        documentation: Documentation(
                            "Method docs",
                        ),
@@ -605,7 +635,9 @@ impl S {
                        source_range: 94..94,
                        delete: 94..94,
                        insert: "foo",
-                        kind: Field,
+                        kind: SymbolKind(
+                            Field,
+                        ),
                        detail: "{unknown}",
                        documentation: Documentation(
                            "Field docs",
@@ -636,7 +668,9 @@ use self::E::*;
                        source_range: 10..12,
                        delete: 10..12,
                        insert: "E",
-                        kind: Enum,
+                        kind: SymbolKind(
+                            Enum,
+                        ),
                        documentation: Documentation(
                            "enum docs",
                        ),
@@ -646,7 +680,9 @@ use self::E::*;
                        source_range: 10..12,
                        delete: 10..12,
                        insert: "V",
-                        kind: EnumVariant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        detail: "()",
                        documentation: Documentation(
                            "variant docs",
@@ -657,7 +693,9 @@ use self::E::*;
                        source_range: 10..12,
                        delete: 10..12,
                        insert: "my",
-                        kind: Module,
+                        kind: SymbolKind(
+                            Module,
+                        ),
                        documentation: Documentation(
                            "mod docs",
                        ),
@@ -687,7 +725,7 @@ fn foo(s: S) { s.$0 }
                        insert: "the_method()$0",
                        kind: Method,
                        lookup: "the_method",
-                        detail: "fn the_method(&self)",
+                        detail: "-> ()",
                    },
                ]
            "#]],
@@ -883,7 +921,7 @@ struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
 "#,
            expect![[r#"
-                bn world [type+name]
+                lc world [type+name]
                st WorldSnapshot []
                fn go(…) []
            "#]],
@@ -900,7 +938,7 @@ fn f(foo: &Foo) { f(foo, w$0) }
            expect![[r#"
                st Foo []
                fn f(…) []
-                bn foo []
+                lc foo []
            "#]],
        );
    }
diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs
index e46452d4e..5010b642a 100644
--- a/crates/completion/src/render/const_.rs
+++ b/crates/completion/src/render/const_.rs
@@ -1,13 +1,14 @@
 //! Renderer for `const` fields.
 use hir::HasSource;
+use ide_db::SymbolKind;
 use syntax::{
    ast::{Const, NameOwner},
    display::const_label,
 };
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionKind},
    render::RenderContext,
 };
@@ -36,7 +37,7 @@ impl<'a> ConstRender<'a> {
        let detail = self.detail();
        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
-            .kind(CompletionItemKind::Const)
+            .kind(SymbolKind::Const)
            .set_documentation(self.ctx.docs(self.const_))
            .set_deprecated(
                self.ctx.is_deprecated(self.const_)
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 89fb49773..adcddebd1 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -1,11 +1,12 @@
 //! Renderer for `enum` variants.
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
+use ide_db::SymbolKind;
 use itertools::Itertools;
 use test_utils::mark;
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportEdit},
+    item::{CompletionItem, CompletionKind, ImportEdit},
    render::{builder_ext::Params, RenderContext},
 };
@@ -60,7 +61,7 @@ impl<'a> EnumRender<'a> {
            self.ctx.source_range(),
            self.qualified_name.clone(),
        )
-        .kind(CompletionItemKind::EnumVariant)
+        .kind(SymbolKind::Variant)
        .set_documentation(self.variant.docs(self.ctx.db()))
        .set_deprecated(self.ctx.is_deprecated(self.variant))
        .add_import(import_to_add)
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 8f4c66211..e46e21d24 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -1,7 +1,8 @@
 //! Renderer for function calls.
-use hir::{HasSource, Type};
+use hir::{HasSource, HirDisplay, Type};
-use syntax::{ast::Fn, display::function_declaration};
+use ide_db::SymbolKind;
+use syntax::ast::Fn;
 use test_utils::mark;
 use crate::{
@@ -54,7 +55,8 @@ impl<'a> FunctionRender<'a> {
    }
    fn detail(&self) -> String {
-        function_declaration(&self.ast_node)
+        let ty = self.func.ret_type(self.ctx.db());
+        format!("-> {}", ty.display(self.ctx.db()))
    }
    fn add_arg(&self, arg: &str, ty: &Type) -> String {
@@ -105,7 +107,7 @@ impl<'a> FunctionRender<'a> {
        if self.func.self_param(self.ctx.db()).is_some() {
            CompletionItemKind::Method
        } else {
-            CompletionItemKind::Function
+            SymbolKind::Function.into()
        }
    }
 }
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index f893e420a..a4535786f 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -1,11 +1,12 @@
 //! Renderer for macro invocations.
 use hir::{Documentation, HasSource};
+use ide_db::SymbolKind;
 use syntax::display::macro_label;
 use test_utils::mark;
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportEdit},
+    item::{CompletionItem, CompletionKind, ImportEdit},
    render::RenderContext,
 };
@@ -41,7 +42,7 @@ impl<'a> MacroRender<'a> {
    fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
        let mut builder =
            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label())
-                .kind(CompletionItemKind::Macro)
+                .kind(SymbolKind::Macro)
                .set_documentation(self.docs.clone())
                .set_deprecated(self.ctx.is_deprecated(self.macro_))
                .add_import(import_to_add)
diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs
index 29287143a..bd97c3692 100644
--- a/crates/completion/src/render/type_alias.rs
+++ b/crates/completion/src/render/type_alias.rs
@@ -1,13 +1,14 @@
 //! Renderer for type aliases.
 use hir::HasSource;
+use ide_db::SymbolKind;
 use syntax::{
    ast::{NameOwner, TypeAlias},
    display::type_label,
 };
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionKind},
    render::RenderContext,
 };
@@ -36,7 +37,7 @@ impl<'a> TypeAliasRender<'a> {
        let detail = self.detail();
        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
-            .kind(CompletionItemKind::TypeAlias)
+            .kind(SymbolKind::TypeAlias)
            .set_documentation(self.ctx.docs(self.type_alias))
            .set_deprecated(
                self.ctx.is_deprecated(self.type_alias)
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index aaa7013b6..e9bb4f541 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -18,8 +18,8 @@ use hir_def::{
    type_ref::{Mutability, TypeRef},
    AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId,
    DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId, LifetimeParamId,
-    LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId, TraitId,
+    LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
-    TypeAliasId, TypeParamId, UnionId,
+    TypeParamId, UnionId,
 };
 use hir_def::{find_path::PrefixKind, item_scope::ItemInNs, visibility::Visibility};
 use hir_expand::{
@@ -90,8 +90,8 @@ impl Crate {
    }
    pub fn root_module(self, db: &dyn HirDatabase) -> Module {
-        let module_id = db.crate_def_map(self.id).root();
+        let def_map = db.crate_def_map(self.id);
-        Module::new(self, module_id)
+        Module { id: def_map.module_id(def_map.root()) }
    }
    pub fn root_file(self, db: &dyn HirDatabase) -> FileId {
@@ -270,18 +270,14 @@ impl ModuleDef {
            None => return,
        };
-        hir_ty::diagnostics::validate_module_item(db, module.id.krate, id, sink)
+        hir_ty::diagnostics::validate_module_item(db, module.id.krate(), id, sink)
    }
 }
 impl Module {
-    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
-        Module { id: ModuleId { krate: krate.id, local_id: crate_module_id } }
-    }
    /// Name of this module.
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        let parent = def_map[self.id.local_id].parent?;
        def_map[parent].children.iter().find_map(|(name, module_id)| {
            if *module_id == self.id.local_id {
@@ -294,33 +290,34 @@ impl Module {
    /// Returns the crate this module is part of.
    pub fn krate(self) -> Crate {
-        Crate { id: self.id.krate }
+        Crate { id: self.id.krate() }
    }
    /// Topmost parent of this module. Every module has a `crate_root`, but some
    /// might be missing `krate`. This can happen if a module's file is not included
    /// in the module tree of any target in `Cargo.toml`.
    pub fn crate_root(self, db: &dyn HirDatabase) -> Module {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = db.crate_def_map(self.id.krate());
-        self.with_module_id(def_map.root())
+        Module { id: def_map.module_id(def_map.root()) }
    }
    /// Iterates over all child modules.
    pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        let children = def_map[self.id.local_id]
            .children
            .iter()
-            .map(|(_, module_id)| self.with_module_id(*module_id))
+            .map(|(_, module_id)| Module { id: def_map.module_id(*module_id) })
            .collect::<Vec<_>>();
        children.into_iter()
    }
    /// Finds a parent module.
    pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {
-        let def_map = db.crate_def_map(self.id.krate);
+        // FIXME: handle block expressions as modules (their parent is in a different DefMap)
+        let def_map = self.id.def_map(db.upcast());
        let parent_id = def_map[self.id.local_id].parent?;
-        Some(self.with_module_id(parent_id))
+        Some(Module { id: def_map.module_id(parent_id) })
    }
    pub fn path_to_root(self, db: &dyn HirDatabase) -> Vec<Module> {
@@ -339,7 +336,7 @@ impl Module {
        db: &dyn HirDatabase,
        visible_from: Option<Module>,
    ) -> Vec<(Name, ScopeDef)> {
-        db.crate_def_map(self.id.krate)[self.id.local_id]
+        self.id.def_map(db.upcast())[self.id.local_id]
            .scope
            .entries()
            .filter_map(|(name, def)| {
@@ -362,14 +359,14 @@ impl Module {
    }
    pub fn visibility_of(self, db: &dyn HirDatabase, def: &ModuleDef) -> Option<Visibility> {
-        db.crate_def_map(self.id.krate)[self.id.local_id].scope.visibility_of(def.clone().into())
+        self.id.def_map(db.upcast())[self.id.local_id].scope.visibility_of(def.clone().into())
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
        let _p = profile::span("Module::diagnostics").detail(|| {
            format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
        });
-        let crate_def_map = db.crate_def_map(self.id.krate);
+        let crate_def_map = self.id.def_map(db.upcast());
        crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
        for decl in self.declarations(db) {
            match decl {
@@ -396,19 +393,15 @@ impl Module {
    }
    pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        def_map[self.id.local_id].scope.declarations().map(ModuleDef::from).collect()
    }
    pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        def_map[self.id.local_id].scope.impls().map(Impl::from).collect()
    }
-    pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module {
-        Module::new(self.krate(), module_id)
-    }
    /// Finds a path that can be used to refer to the given item from within
    /// this module, if possible.
    pub fn find_use_path(self, db: &dyn DefDatabase, item: impl Into<ItemInNs>) -> Option<ModPath> {
@@ -457,7 +450,7 @@ impl Field {
        };
        let substs = Substs::type_params(db, generic_def_id);
        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
-        Type::new(db, self.parent.module(db).id.krate, var_id, ty)
+        Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
    }
    pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
@@ -502,7 +495,11 @@ impl Struct {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
+        Type::from_def(
+            db,
+            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
+            self.id,
+        )
    }
    pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprKind> {
@@ -533,7 +530,11 @@ impl Union {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
+        Type::from_def(
+            db,
+            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
+            self.id,
+        )
    }
    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@@ -573,7 +574,11 @@ impl Enum {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
+        Type::from_def(
+            db,
+            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
+            self.id,
+        )
    }
 }
@@ -632,7 +637,7 @@ impl Adt {
    /// general set of completions, but will not look very nice when printed.
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
        let id = AdtId::from(self);
-        Type::from_def(db, id.module(db.upcast()).krate, id)
+        Type::from_def(db, id.module(db.upcast()).krate(), id)
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -750,7 +755,7 @@ impl Function {
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
        let environment = TraitEnvironment::lower(db, &resolver);
        Type {
-            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
            ty: InEnvironment { value: Ty::from_hir_ext(&ctx, ret_type).0, environment },
        }
    }
@@ -771,7 +776,7 @@ impl Function {
            .iter()
            .map(|type_ref| {
                let ty = Type {
-                    krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+                    krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
                    ty: InEnvironment {
                        value: Ty::from_hir_ext(&ctx, type_ref).0,
                        environment: environment.clone(),
@@ -795,7 +800,7 @@ impl Function {
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
-        let krate = self.module(db).id.krate;
+        let krate = self.module(db).id.krate();
        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
@@ -973,7 +978,7 @@ impl TypeAlias {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db.upcast()).module(db.upcast()).krate, self.id)
+        Type::from_def(db, self.id.lookup(db.upcast()).module(db.upcast()).krate(), self.id)
    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
@@ -1000,8 +1005,9 @@ impl MacroDef {
    /// early, in `hir_expand`, where modules simply do not exist yet.
    pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
        let krate = self.id.krate;
-        let module_id = db.crate_def_map(krate).root();
+        let def_map = db.crate_def_map(krate);
-        Some(Module::new(Crate { id: krate }, module_id))
+        let module_id = def_map.root();
+        Some(Module { id: def_map.module_id(module_id) })
    }
    /// XXX: this parses the file
@@ -1230,7 +1236,7 @@ impl Local {
        let def = DefWithBodyId::from(self.parent);
        let infer = db.infer(def);
        let ty = infer[self.pat_id].clone();
-        let krate = def.module(db.upcast()).krate;
+        let krate = def.module(db.upcast()).krate();
        Type::new(db, krate, def, ty)
    }
@@ -1318,7 +1324,7 @@ impl TypeParam {
        let environment = TraitEnvironment::lower(db, &resolver);
        let ty = Ty::Placeholder(self.id);
        Type {
-            krate: self.id.parent.module(db.upcast()).krate,
+            krate: self.id.parent.module(db.upcast()).krate(),
            ty: InEnvironment { value: ty, environment },
        }
    }
@@ -1344,7 +1350,7 @@ impl TypeParam {
        let subst = Substs::type_params(db, self.id.parent);
        let ty = ty.subst(&subst.prefix(local_idx));
        Some(Type {
-            krate: self.id.parent.module(db.upcast()).krate,
+            krate: self.id.parent.module(db.upcast()).krate(),
            ty: InEnvironment { value: ty, environment },
        })
    }
@@ -1405,7 +1411,7 @@ impl ConstParam {
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
        let def = self.id.parent;
-        let krate = def.module(db.upcast()).krate;
+        let krate = def.module(db.upcast()).krate();
        Type::new(db, krate, def, db.const_param_ty(self.id))
    }
 }
@@ -1440,7 +1446,7 @@ impl Impl {
        let environment = TraitEnvironment::lower(db, &resolver);
        let ty = Ty::from_hir(&ctx, &impl_data.target_type);
        Type {
-            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
            ty: InEnvironment { value: ty, environment },
        }
    }
@@ -1458,7 +1464,7 @@ impl Impl {
    }
    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        Crate { id: self.module(db).id.krate }
+        Crate { id: self.module(db).id.krate() }
    }
    pub fn is_builtin_derive(self, db: &dyn HirDatabase) -> Option<InFile<ast::Attr>> {
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 447faa04f..5343a036c 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -5,5 +5,5 @@ pub use hir_expand::diagnostics::{
 };
 pub use hir_ty::diagnostics::{
    IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
-    NoSuchField, RemoveThisSemicolon,
+    NoSuchField, RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap,
 };
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 7c57d8378..262002671 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -24,12 +24,12 @@ pub trait HasSource {
 impl Module {
    /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
    pub fn definition_source(self, db: &dyn HirDatabase) -> InFile<ModuleSource> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        def_map[self.id.local_id].definition_source(db.upcast())
    }
    pub fn is_mod_rs(self, db: &dyn HirDatabase) -> bool {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        match def_map[self.id.local_id].origin {
            ModuleOrigin::File { is_mod_rs, .. } => is_mod_rs,
            _ => false,
@@ -39,7 +39,7 @@ impl Module {
    /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
    /// `None` for the crate root.
    pub fn declaration_source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Module>> {
-        let def_map = db.crate_def_map(self.id.krate);
+        let def_map = self.id.def_map(db.upcast());
        def_map[self.id.local_id].declaration_source(db.upcast())
    }
 }
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 9bf60c72a..6c612ee86 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -30,12 +30,12 @@ pub(super) struct SourceToDefCtx<'a, 'b> {
 impl SourceToDefCtx<'_, '_> {
    pub(super) fn file_to_def(&mut self, file: FileId) -> Option<ModuleId> {
        let _p = profile::span("SourceBinder::to_module_def");
-        let (krate, local_id) = self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+        self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+            // FIXME: inner items
            let crate_def_map = self.db.crate_def_map(crate_id);
            let local_id = crate_def_map.modules_for_file(file).next()?;
-            Some((crate_id, local_id))
+            Some(crate_def_map.module_id(local_id))
-        })?;
+        })
-        Some(ModuleId { krate, local_id })
    }
    pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> {
@@ -60,9 +60,9 @@ impl SourceToDefCtx<'_, '_> {
        }?;
        let child_name = src.value.name()?.as_name();
-        let def_map = self.db.crate_def_map(parent_module.krate);
+        let def_map = parent_module.def_map(self.db.upcast());
        let child_id = *def_map[parent_module.local_id].children.get(&child_name)?;
-        Some(ModuleId { krate: parent_module.krate, local_id: child_id })
+        Some(def_map.module_id(child_id))
    }
    pub(super) fn trait_to_def(&mut self, src: InFile<ast::Trait>) -> Option<TraitId> {
@@ -185,7 +185,7 @@ impl SourceToDefCtx<'_, '_> {
    ) -> Option<MacroDefId> {
        let kind = MacroDefKind::Declarative;
        let file_id = src.file_id.original_file(self.db.upcast());
-        let krate = self.file_to_def(file_id)?.krate;
+        let krate = self.file_to_def(file_id)?.krate();
        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
        let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast()));
        Some(MacroDefId { krate, ast_id, kind, local_inner: false })
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index c72649c41..6513daec8 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -196,7 +196,7 @@ impl Attrs {
    pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
        let raw_attrs = match def {
            AttrDefId::ModuleId(module) => {
-                let def_map = db.crate_def_map(module.krate);
+                let def_map = module.def_map(db);
                let mod_data = &def_map[module.local_id];
                match mod_data.declaration_source(db) {
                    Some(it) => {
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 2c2c999dd..d0c84ab0b 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -86,7 +86,7 @@ impl Expander {
        module: ModuleId,
    ) -> Expander {
        let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
-        let crate_def_map = db.crate_def_map(module.krate);
+        let crate_def_map = module.def_map(db);
        let ast_id_map = db.ast_id_map(current_file_id);
        Expander {
            cfg_expander,
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index dcb00a1d9..65d85c86a 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -74,7 +74,7 @@ impl ChildBySource for ImplId {
 impl ChildBySource for ModuleId {
    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
-        let crate_def_map = db.crate_def_map(self.krate);
+        let crate_def_map = self.def_map(db);
        let module_data = &crate_def_map[self.local_id];
        module_data.scope.child_by_source(db)
    }
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index a87c80b8a..aef7e1f6c 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,9 @@
 use std::sync::Arc;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
-use hir_expand::{db::AstDatabase, AstId, HirFileId};
+use hir_expand::{db::AstDatabase, HirFileId};
 use la_arena::ArenaMap;
-use syntax::{ast, SmolStr};
+use syntax::SmolStr;
 use crate::{
    adt::{EnumData, StructData},
@@ -16,9 +16,10 @@ use crate::{
    item_tree::ItemTree,
    lang_item::{LangItemTarget, LangItems},
    nameres::DefMap,
-    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
+    AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId,
-    GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
+    FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId,
-    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
+    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
+    UnionLoc, VariantId,
 };
 #[salsa::query_group(InternDatabaseStorage)]
@@ -41,6 +42,8 @@ pub trait InternDatabase: SourceDatabase {
    fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
    #[salsa::interned]
    fn intern_impl(&self, loc: ImplLoc) -> ImplId;
+    #[salsa::interned]
+    fn intern_block(&self, loc: BlockLoc) -> BlockId;
 }
 #[salsa::query_group(DefDatabaseStorage)]
@@ -56,7 +59,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
    #[salsa::invoke(DefMap::block_def_map_query)]
-    fn block_def_map(&self, krate: CrateId, block: AstId<ast::BlockExpr>) -> Arc<DefMap>;
+    fn block_def_map(&self, block: BlockId) -> Arc<DefMap>;
    #[salsa::invoke(StructData::struct_data_query)]
    fn struct_data(&self, id: StructId) -> Arc<StructData>;
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index db2d125ae..94a1d567d 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -53,12 +53,8 @@ fn check_self_super(def_map: &DefMap, item: ItemInNs, from: ModuleId) -> Option<
        Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
    } else if let Some(parent_id) = def_map[from.local_id].parent {
        // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
-        if item
+        let parent_id = def_map.module_id(parent_id);
-            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+        if item == ItemInNs::Types(ModuleDefId::ModuleId(parent_id)) {
-                krate: from.krate,
-                local_id: parent_id,
-            }))
-        {
            Some(ModPath::from_segments(PathKind::Super(1), Vec::new()))
        } else {
            None
@@ -110,7 +106,7 @@ fn find_path_inner(
    // Base cases:
    // - if the item is already in scope, return the name under which it is
-    let def_map = db.crate_def_map(from.krate);
+    let def_map = from.def_map(db);
    let from_scope: &crate::item_scope::ItemScope = &def_map[from.local_id].scope;
    let scope_name =
        if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
@@ -120,12 +116,8 @@ fn find_path_inner(
    }
    // - if the item is the crate root, return `crate`
-    if item
+    let root = def_map.module_id(def_map.root());
-        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+    if item == ItemInNs::Types(ModuleDefId::ModuleId(root)) {
-            krate: from.krate,
-            local_id: def_map.root(),
-        }))
-    {
        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
    }
@@ -145,7 +137,7 @@ fn find_path_inner(
    // - if the item is in the prelude, return the name from there
    if let Some(prelude_module) = def_map.prelude() {
-        let prelude_def_map = db.crate_def_map(prelude_module.krate);
+        let prelude_def_map = prelude_module.def_map(db);
        let prelude_scope: &crate::item_scope::ItemScope =
            &prelude_def_map[prelude_module.local_id].scope;
        if let Some((name, vis)) = prelude_scope.name_of(item) {
@@ -175,7 +167,7 @@ fn find_path_inner(
    // - otherwise, look for modules containing (reexporting) it and import it from one of those
-    let crate_root = ModuleId { local_id: def_map.root(), krate: from.krate };
+    let crate_root = def_map.module_id(def_map.root());
    let crate_attrs = db.attrs(crate_root.into());
    let prefer_no_std = crate_attrs.by_key("no_std").exists();
    let mut best_path = None;
@@ -283,19 +275,16 @@ fn find_local_import_locations(
    // above `from` with any visibility. That means we do not need to descend into private siblings
    // of `from` (and similar).
-    let def_map = db.crate_def_map(from.krate);
+    let def_map = from.def_map(db);
    // Compute the initial worklist. We start with all direct child modules of `from` as well as all
    // of its (recursive) parent modules.
    let data = &def_map[from.local_id];
-    let mut worklist = data
+    let mut worklist =
-        .children
+        data.children.values().map(|child| def_map.module_id(*child)).collect::<Vec<_>>();
-        .values()
-        .map(|child| ModuleId { krate: from.krate, local_id: *child })
-        .collect::<Vec<_>>();
    let mut parent = data.parent;
    while let Some(p) = parent {
-        worklist.push(ModuleId { krate: from.krate, local_id: p });
+        worklist.push(def_map.module_id(p));
        parent = def_map[p].parent;
    }
@@ -312,7 +301,7 @@ fn find_local_import_locations(
            &def_map[module.local_id]
        } else {
            // The crate might reexport a module defined in another crate.
-            ext_def_map = db.crate_def_map(module.krate);
+            ext_def_map = module.def_map(db);
            &ext_def_map[module.local_id]
        };
@@ -375,7 +364,7 @@ mod tests {
            parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
        let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
-        let crate_def_map = db.crate_def_map(module.krate);
+        let crate_def_map = module.def_map(&db);
        let resolved = crate_def_map
            .resolve_path(
                &db,
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 0251d016b..0a3dc7956 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -75,7 +75,7 @@ impl ImportMap {
        // We look only into modules that are public(ly reexported), starting with the crate root.
        let empty = ImportPath { segments: vec![] };
-        let root = ModuleId { krate, local_id: def_map.root() };
+        let root = def_map.module_id(def_map.root());
        let mut worklist = vec![(root, empty)];
        while let Some((module, mod_path)) = worklist.pop() {
            let ext_def_map;
@@ -83,7 +83,7 @@ impl ImportMap {
                &def_map[module.local_id]
            } else {
                // The crate might reexport a module defined in another crate.
-                ext_def_map = db.crate_def_map(module.krate);
+                ext_def_map = module.def_map(db);
                &ext_def_map[module.local_id]
            };
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index b8d7608e7..1e5c94660 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -66,7 +66,7 @@ impl GenericParamsId {
 }
 /// The item tree of a source file.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Default, Eq, PartialEq)]
 pub struct ItemTree {
    _c: Count<Self>,
@@ -82,7 +82,7 @@ impl ItemTree {
        let syntax = if let Some(node) = db.parse_or_expand(file_id) {
            node
        } else {
-            return Arc::new(Self::empty());
+            return Default::default();
        };
        let hygiene = Hygiene::new(db.upcast(), file_id);
@@ -118,15 +118,6 @@ impl ItemTree {
        Arc::new(item_tree)
    }
-    fn empty() -> Self {
-        Self {
-            _c: Count::new(),
-            top_level: Default::default(),
-            attrs: Default::default(),
-            data: Default::default(),
-        }
-    }
    fn shrink_to_fit(&mut self) {
        if let Some(data) = &mut self.data {
            let ItemTreeData {
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index ce470fc3b..8a71376b9 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -43,7 +43,7 @@ pub(super) struct Ctx {
 impl Ctx {
    pub(super) fn new(db: &dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self {
        Self {
-            tree: ItemTree::empty(),
+            tree: ItemTree::default(),
            hygiene,
            file,
            source_ast_id_map: db.ast_id_map(file),
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 08ed920c6..42b50b5b7 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -50,7 +50,10 @@ pub mod import_map;
 #[cfg(test)]
 mod test_db;
-use std::hash::{Hash, Hasher};
+use std::{
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
 use base_db::{impl_intern_key, salsa, CrateId};
 use hir_expand::{
@@ -58,6 +61,7 @@ use hir_expand::{
    MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use la_arena::Idx;
+use nameres::DefMap;
 use syntax::ast;
 use crate::builtin_type::BuiltinType;
@@ -69,10 +73,24 @@ use stdx::impl_from;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
-    pub krate: CrateId,
+    krate: CrateId,
+    block: Option<BlockId>,
    pub local_id: LocalModuleId,
 }
+impl ModuleId {
+    pub fn def_map(&self, db: &dyn db::DefDatabase) -> Arc<DefMap> {
+        match self.block {
+            Some(block) => db.block_def_map(block),
+            None => db.crate_def_map(self.krate),
+        }
+    }
+    pub fn krate(&self) -> CrateId {
+        self.krate
+    }
+}
 /// An ID of a module, **local** to a specific crate
 pub type LocalModuleId = Idx<nameres::ModuleData>;
@@ -216,6 +234,15 @@ pub struct ImplId(salsa::InternId);
 type ImplLoc = ItemLoc<Impl>;
 impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct BlockId(salsa::InternId);
+#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+pub struct BlockLoc {
+    ast_id: AstId<ast::BlockExpr>,
+    module: ModuleId,
+}
+impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeParamId {
    pub parent: GenericDefId,
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index bd3ea9b8b..199771e9a 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -62,7 +62,7 @@ use la_arena::Arena;
 use profile::Count;
 use rustc_hash::FxHashMap;
 use stdx::format_to;
-use syntax::{ast, AstNode};
+use syntax::ast;
 use crate::{
    db::DefDatabase,
@@ -70,14 +70,14 @@ use crate::{
    nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
    path::ModPath,
    per_ns::PerNs,
-    AstId, LocalModuleId, ModuleDefId, ModuleId,
+    AstId, BlockId, BlockLoc, LocalModuleId, ModuleDefId, ModuleId,
 };
 /// Contains all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
 pub struct DefMap {
    _c: Count<Self>,
-    parent: Option<Arc<DefMap>>,
+    block: Option<BlockInfo>,
    root: LocalModuleId,
    modules: Arena<ModuleData>,
    krate: CrateId,
@@ -91,6 +91,13 @@ pub struct DefMap {
    diagnostics: Vec<DefDiagnostic>,
 }
+#[derive(Debug, PartialEq, Eq)]
+struct BlockInfo {
+    block: BlockId,
+    parent: Arc<DefMap>,
+    parent_module: LocalModuleId,
+}
 impl std::ops::Index<LocalModuleId> for DefMap {
    type Output = ModuleData;
    fn index(&self, id: LocalModuleId) -> &ModuleData {
@@ -190,15 +197,12 @@ impl DefMap {
        Arc::new(def_map)
    }
-    pub(crate) fn block_def_map_query(
+    pub(crate) fn block_def_map_query(db: &dyn DefDatabase, block_id: BlockId) -> Arc<DefMap> {
-        db: &dyn DefDatabase,
+        let block: BlockLoc = db.lookup_intern_block(block_id);
-        krate: CrateId,
+        let item_tree = db.item_tree(block.ast_id.file_id);
-        block: AstId<ast::BlockExpr>,
+        let block_items = item_tree.inner_items_of_block(block.ast_id.value);
-    ) -> Arc<DefMap> {
-        let item_tree = db.item_tree(block.file_id);
-        let block_items = item_tree.inner_items_of_block(block.value);
-        let parent = parent_def_map(db, krate, block);
+        let parent = block.module.def_map(db);
        if block_items.is_empty() {
            // If there are no inner items, nothing new is brought into scope, so we can just return
@@ -206,10 +210,13 @@ impl DefMap {
            return parent;
        }
-        let mut def_map = DefMap::empty(krate, parent.edition);
+        let block_info =
-        def_map.parent = Some(parent);
+            BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
+        let mut def_map = DefMap::empty(block.module.krate, block_info.parent.edition);
+        def_map.block = Some(block_info);
-        let def_map = collector::collect_defs(db, def_map, Some(block.value));
+        let def_map = collector::collect_defs(db, def_map, Some(block.ast_id.value));
        Arc::new(def_map)
    }
@@ -218,7 +225,7 @@ impl DefMap {
        let root = modules.alloc(ModuleData::default());
        DefMap {
            _c: Count::new(),
-            parent: None,
+            block: None,
            krate,
            edition,
            extern_prelude: FxHashMap::default(),
@@ -265,6 +272,11 @@ impl DefMap {
        self.extern_prelude.iter()
    }
+    pub fn module_id(&self, local_id: LocalModuleId) -> ModuleId {
+        let block = self.block.as_ref().map(|b| b.block);
+        ModuleId { krate: self.krate, local_id, block }
+    }
    pub(crate) fn resolve_path(
        &self,
        db: &dyn DefDatabase,
@@ -282,9 +294,9 @@ impl DefMap {
    pub fn dump(&self) -> String {
        let mut buf = String::new();
        let mut current_map = self;
-        while let Some(parent) = &current_map.parent {
+        while let Some(block) = &current_map.block {
            go(&mut buf, current_map, "block scope", current_map.root);
-            current_map = &**parent;
+            current_map = &*block.parent;
        }
        go(&mut buf, current_map, "crate", current_map.root);
        return buf;
@@ -338,35 +350,6 @@ impl ModuleData {
    }
 }
-fn parent_def_map(
-    db: &dyn DefDatabase,
-    krate: CrateId,
-    block: AstId<ast::BlockExpr>,
-) -> Arc<DefMap> {
-    // FIXME: store this info in the item tree instead of reparsing here
-    let ast_id_map = db.ast_id_map(block.file_id);
-    let block_ptr = ast_id_map.get(block.value);
-    let root = match db.parse_or_expand(block.file_id) {
-        Some(it) => it,
-        None => {
-            return Arc::new(DefMap::empty(krate, Edition::Edition2018));
-        }
-    };
-    let ast = block_ptr.to_node(&root);
-    for ancestor in ast.syntax().ancestors().skip(1) {
-        if let Some(block_expr) = ast::BlockExpr::cast(ancestor) {
-            let ancestor_id = ast_id_map.ast_id(&block_expr);
-            let ast_id = InFile::new(block.file_id, ancestor_id);
-            let parent_map = db.block_def_map(krate, ast_id);
-            return parent_map;
-        }
-    }
-    // No enclosing block scope, so the parent is the crate-level DefMap.
-    db.crate_def_map(krate)
-}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ModuleSource {
    SourceFile(ast::SourceFile),
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index cd68efbe6..393170b32 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -37,8 +37,8 @@ use crate::{
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
    AdtId, AsMacroCall, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId,
-    FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc,
+    FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc,
-    TraitLoc, TypeAliasLoc, UnionLoc,
+    TypeAliasLoc, UnionLoc,
 };
 const GLOB_RECURSION_LIMIT: usize = 100;
@@ -56,10 +56,9 @@ pub(super) fn collect_defs(
    for dep in &crate_graph[def_map.krate].dependencies {
        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
        let dep_def_map = db.crate_def_map(dep.crate_id);
-        def_map.extern_prelude.insert(
+        def_map
-            dep.as_name(),
+            .extern_prelude
-            ModuleId { krate: dep.crate_id, local_id: dep_def_map.root }.into(),
+            .insert(dep.as_name(), dep_def_map.module_id(dep_def_map.root).into());
-        );
        // look for the prelude
        // If the dependency defines a prelude, we overwrite an already defined
@@ -332,11 +331,9 @@ impl DefCollector<'_> {
            // exported in type/value namespace. This function reduces the visibility of all items
            // in the crate root that aren't proc macros.
            let root = self.def_map.root;
+            let module_id = self.def_map.module_id(root);
            let root = &mut self.def_map.modules[root];
-            root.scope.censor_non_proc_macros(ModuleId {
+            root.scope.censor_non_proc_macros(module_id);
-                krate: self.def_map.krate,
-                local_id: self.def_map.root,
-            });
        }
    }
@@ -578,7 +575,7 @@ impl DefCollector<'_> {
                    } else if m.krate != self.def_map.krate {
                        mark::hit!(glob_across_crates);
                        // glob import from other crate => we can just import everything once
-                        let item_map = self.db.crate_def_map(m.krate);
+                        let item_map = m.def_map(self.db);
                        let scope = &item_map[m.local_id].scope;
                        // Module scoped macros is included
@@ -1029,8 +1026,7 @@ impl ModCollector<'_, '_> {
                    continue;
                }
            }
-            let module =
+            let module = self.def_collector.def_map.module_id(self.module_id);
-                ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
            let container = ContainerId::ModuleId(module);
            let mut def = None;
@@ -1097,10 +1093,7 @@ impl ModCollector<'_, '_> {
                    }
                }
                ModItem::Impl(imp) => {
-                    let module = ModuleId {
+                    let module = self.def_collector.def_map.module_id(self.module_id);
-                        krate: self.def_collector.def_map.krate,
-                        local_id: self.module_id,
-                    };
                    let container = ContainerId::ModuleId(module);
                    let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
                        .intern(self.def_collector.db);
@@ -1343,7 +1336,7 @@ impl ModCollector<'_, '_> {
            modules[res].scope.define_legacy_macro(name, mac)
        }
        modules[self.module_id].children.insert(name.clone(), res);
-        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
+        let module = self.def_collector.def_map.module_id(res);
        let def: ModuleDefId = module.into();
        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
        self.def_collector.update(
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index ec90f4e65..419e465ed 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -10,9 +10,8 @@
 //!
 //! `ReachedFixedPoint` signals about this.
-use std::iter::successors;
 use base_db::Edition;
+use hir_expand::name;
 use hir_expand::name::Name;
 use test_utils::mark;
@@ -23,7 +22,7 @@ use crate::{
    path::{ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
-    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
+    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId,
 };
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -63,6 +62,10 @@ impl ResolvePathResult {
 impl DefMap {
    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
+        if name == &name!(self) {
+            mark::hit!(extern_crate_self_as);
+            return PerNs::types(self.module_id(self.root).into(), Visibility::Public);
+        }
        self.extern_prelude
            .get(name)
            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
@@ -126,8 +129,8 @@ impl DefMap {
            result.krate = result.krate.or(new.krate);
            result.segment_index = result.segment_index.min(new.segment_index);
-            match &current_map.parent {
+            match &current_map.block {
-                Some(map) => current_map = map,
+                Some(block) => current_map = &block.parent,
                None => return result,
            }
        }
@@ -146,21 +149,15 @@ impl DefMap {
            PathKind::DollarCrate(krate) => {
                if krate == self.krate {
                    mark::hit!(macro_dollar_crate_self);
-                    PerNs::types(
+                    PerNs::types(self.module_id(self.root).into(), Visibility::Public)
-                        ModuleId { krate: self.krate, local_id: self.root }.into(),
-                        Visibility::Public,
-                    )
                } else {
                    let def_map = db.crate_def_map(krate);
-                    let module = ModuleId { krate, local_id: def_map.root };
+                    let module = def_map.module_id(def_map.root);
                    mark::hit!(macro_dollar_crate_other);
                    PerNs::types(module.into(), Visibility::Public)
                }
            }
-            PathKind::Crate => PerNs::types(
+            PathKind::Crate => PerNs::types(self.module_id(self.root).into(), Visibility::Public),
-                ModuleId { krate: self.krate, local_id: self.root }.into(),
-                Visibility::Public,
-            ),
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -194,17 +191,35 @@ impl DefMap {
                self.resolve_name_in_module(db, original_module, &segment, prefer_module)
            }
            PathKind::Super(lvl) => {
-                let m = successors(Some(original_module), |m| self.modules[*m].parent)
+                let mut module = original_module;
-                    .nth(lvl as usize);
+                for i in 0..lvl {
-                if let Some(local_id) = m {
+                    match self.modules[module].parent {
-                    PerNs::types(
+                        Some(it) => module = it,
-                        ModuleId { krate: self.krate, local_id }.into(),
+                        None => match &self.block {
-                        Visibility::Public,
+                            Some(block) => {
-                    )
+                                // Look up remaining path in parent `DefMap`
-                } else {
+                                let new_path = ModPath {
-                    log::debug!("super path in root module");
+                                    kind: PathKind::Super(lvl - i),
-                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                                    segments: path.segments.clone(),
+                                };
+                                log::debug!("`super` path: {} -> {} in parent map", path, new_path);
+                                return block.parent.resolve_path_fp_with_macro(
+                                    db,
+                                    mode,
+                                    block.parent_module,
+                                    &new_path,
+                                    shadow,
+                                );
+                            }
+                            None => {
+                                log::debug!("super path in root module");
+                                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                            }
+                        },
+                    }
                }
+                PerNs::types(self.module_id(module).into(), Visibility::Public)
            }
            PathKind::Abs => {
                // 2018-style absolute path -- only extern prelude
@@ -243,7 +258,7 @@ impl DefMap {
                            kind: PathKind::Super(0),
                        };
                        log::debug!("resolving {:?} in other crate", path);
-                        let defp_map = db.crate_def_map(module.krate);
+                        let defp_map = module.def_map(db);
                        let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
                        return ResolvePathResult::with(
                            def,
@@ -356,7 +371,7 @@ impl DefMap {
                self
            } else {
                // Extend lifetime
-                keep = db.crate_def_map(prelude.krate);
+                keep = prelude.def_map(db);
                &keep
            };
            def_map[prelude.local_id].scope.get(name)
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 73e3a4702..b36d0b59b 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -8,12 +8,12 @@ mod block;
 use std::sync::Arc;
-use base_db::{fixture::WithFixture, SourceDatabase};
+use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
 use expect_test::{expect, Expect};
-use hir_expand::db::AstDatabase;
+use syntax::AstNode;
 use test_utils::mark;
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB, Lookup};
 fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
    let db = TestDB::with_files(ra_fixture);
@@ -23,14 +23,58 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
 fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
    let (db, position) = TestDB::with_position(ra_fixture);
+    // FIXME: perhaps we should make this use body lowering tests instead?
    let module = db.module_for_file(position.file_id);
-    let ast_map = db.ast_id_map(position.file_id.into());
+    let mut def_map = db.crate_def_map(module.krate);
-    let ast = db.parse(position.file_id);
+    while let Some(new_def_map) = descend_def_map_at_position(&db, position, def_map.clone()) {
-    let block: ast::BlockExpr =
+        def_map = new_def_map;
-        syntax::algo::find_node_at_offset(&ast.syntax_node(), position.offset).unwrap();
+    }
-    let block_id = ast_map.ast_id(&block);
+    // FIXME: select the right module, not the root
+    def_map
+}
+fn descend_def_map_at_position(
+    db: &dyn DefDatabase,
+    position: FilePosition,
+    def_map: Arc<DefMap>,
+) -> Option<Arc<DefMap>> {
+    for (local_id, module_data) in def_map.modules() {
+        let mod_def = module_data.origin.definition_source(db);
+        let ast_map = db.ast_id_map(mod_def.file_id);
+        let item_tree = db.item_tree(mod_def.file_id);
+        let root = db.parse_or_expand(mod_def.file_id).unwrap();
+        for item in module_data.scope.declarations() {
+            match item {
+                ModuleDefId::FunctionId(it) => {
+                    // Technically blocks can be inside any type (due to arrays and const generics),
+                    // and also in const/static initializers. For tests we only really care about
+                    // functions though.
+                    let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
+                    if ast.syntax().text_range().contains(position.offset) {
+                        // Cursor inside function, descend into its body's DefMap.
+                        // Note that we don't handle block *expressions* inside function bodies.
+                        let ast_map = db.ast_id_map(position.file_id.into());
+                        let ast_id = ast_map.ast_id(&ast.body().unwrap());
+                        let block = BlockLoc {
+                            ast_id: InFile::new(position.file_id.into(), ast_id),
+                            module: def_map.module_id(local_id),
+                        };
+                        let block_id = db.intern_block(block);
+                        return Some(db.block_def_map(block_id));
+                    }
+                }
+                _ => continue,
+            }
+        }
+    }
-    db.block_def_map(module.krate, InFile::new(position.file_id.into(), block_id))
+    None
 }
 fn check(ra_fixture: &str, expect: Expect) {
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
index 01d6326a7..470ca593e 100644
--- a/crates/hir_def/src/nameres/tests/block.rs
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -95,3 +95,29 @@ fn outer() {
        "#]],
    );
 }
+#[test]
+fn super_imports() {
+    check_at(
+        r#"
+mod module {
+    fn f() {
+        use super::Struct;
+        $0
+    }
+}
+struct Struct {}
+"#,
+        expect![[r#"
+            block scope
+            Struct: t
+            crate
+            Struct: t
+            module: t
+            crate::module
+            f: v
+        "#]],
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index 58d69d3c6..e8e72e5ef 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -62,6 +62,22 @@ fn unresolved_extern_crate() {
 }
 #[test]
+fn extern_crate_self_as() {
+    mark::check!(extern_crate_self_as);
+    check_diagnostics(
+        r"
+        //- /lib.rs
+          extern crate doesnotexist;
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+        // Should not error.
+        extern crate self as foo;
+        struct Foo;
+        use foo::Foo as Bar;
+        ",
+    );
+}
+#[test]
 fn dedup_unresolved_import_from_unresolved_crate() {
    check_diagnostics(
        r"
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index e34cd7f2f..84ea09b53 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -304,6 +304,7 @@ pub use hir_expand::name as __name;
 #[macro_export]
 macro_rules! __known_path {
    (core::iter::IntoIterator) => {};
+    (core::iter::Iterator) => {};
    (core::result::Result) => {};
    (core::option::Option) => {};
    (core::ops::Range) => {};
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index b2f577649..9021ea712 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -430,7 +430,7 @@ impl Resolver {
        for scope in &self.scopes {
            if let Scope::ModuleScope(m) = scope {
                if let Some(prelude) = m.crate_def_map.prelude() {
-                    let prelude_def_map = db.crate_def_map(prelude.krate);
+                    let prelude_def_map = prelude.def_map(db);
                    traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                }
                traits.extend(m.crate_def_map[m.module_id].scope.traits());
@@ -459,7 +459,7 @@ impl Resolver {
    pub fn module(&self) -> Option<ModuleId> {
        let (def_map, local_id) = self.module_scope()?;
-        Some(ModuleId { krate: def_map.krate(), local_id })
+        Some(def_map.module_id(local_id))
    }
    pub fn krate(&self) -> Option<CrateId> {
@@ -529,7 +529,7 @@ impl Scope {
                    f(name.clone(), ScopeDef::PerNs(def));
                });
                if let Some(prelude) = m.crate_def_map.prelude() {
-                    let prelude_def_map = db.crate_def_map(prelude.krate);
+                    let prelude_def_map = prelude.def_map(db);
                    prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
                        let seen_tuple = (name.clone(), def);
                        if !seen.contains(&seen_tuple) {
@@ -633,7 +633,7 @@ pub trait HasResolver: Copy {
 impl HasResolver for ModuleId {
    fn resolver(self, db: &dyn DefDatabase) -> Resolver {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = self.def_map(db);
        Resolver::default().push_module_scope(def_map, self.local_id)
    }
 }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 4ff219fb7..c4e36eda5 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -15,7 +15,7 @@ use rustc_hash::FxHashSet;
 use syntax::{TextRange, TextSize};
 use test_utils::extract_annotations;
-use crate::{db::DefDatabase, ModuleDefId};
+use crate::{db::DefDatabase, ModuleDefId, ModuleId};
 #[salsa::database(
    base_db::SourceDatabaseExtStorage,
@@ -72,12 +72,12 @@ impl FileLoader for TestDB {
 }
 impl TestDB {
-    pub(crate) fn module_for_file(&self, file_id: FileId) -> crate::ModuleId {
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
        for &krate in self.relevant_crates(file_id).iter() {
            let crate_def_map = self.crate_def_map(krate);
            for (local_id, data) in crate_def_map.modules() {
                if data.origin.file_id() == Some(file_id) {
-                    return crate::ModuleId { krate, local_id };
+                    return crate_def_map.module_id(local_id);
                }
            }
        }
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index 3134fa43d..e79a91102 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -103,7 +103,7 @@ impl Visibility {
        if from_module.krate != to_module.krate {
            return false;
        }
-        let def_map = db.crate_def_map(from_module.krate);
+        let def_map = from_module.def_map(db);
        self.is_visible_from_def_map(&def_map, from_module.local_id)
    }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 80b60d59f..57bc6fbd7 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -327,17 +327,14 @@ fn concat_expand(
                // concat works with string and char literals, so remove any quotes.
                // It also works with integer, float and boolean literals, so just use the rest
                // as-is.
+                let component = unquote_str(&it).unwrap_or_else(|| it.text.to_string());
-                text += it
+                text.push_str(&component);
-                    .text
+            }
-                    .trim_start_matches(|c| match c {
+            // handle boolean literals
-                        'r' | '#' | '\'' | '"' => true,
+            tt::TokenTree::Leaf(tt::Leaf::Ident(id))
-                        _ => false,
+                if i % 2 == 0 && (id.text == "true" || id.text == "false") =>
-                    })
+            {
-                    .trim_end_matches(|c| match c {
+                text.push_str(id.text.as_str());
-                        '#' | '\'' | '"' => true,
-                        _ => false,
-                    });
            }
            tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
            _ => {
@@ -345,7 +342,6 @@ fn concat_expand(
            }
        }
    }
    ExpandResult { value: Some((quote!(#text), FragmentKind::Expr)), err }
 }
@@ -745,12 +741,10 @@ mod tests {
            r##"
            #[rustc_builtin_macro]
            macro_rules! concat {}
-            concat!("foo", 0, r#"bar"#);
+            concat!("foo", "r", 0, r#"bar"#, false);
            "##,
        );
-        assert_eq!(expanded, r#""foo0bar""#);
+        assert_eq!(expanded, r#""foor0barfalse""#);
-        // FIXME: `true`/`false` literals don't work.
    }
 }
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index d692cec14..c7609e90d 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -186,6 +186,9 @@ pub mod known {
        Neg,
        Not,
        Index,
+        // Components of known path (function name)
+        filter_map,
+        next,
        // Builtin macros
        file,
        column,
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 247da43f2..323c5f963 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -247,7 +247,7 @@ impl Diagnostic for RemoveThisSemicolon {
 // Diagnostic: break-outside-of-loop
 //
-// This diagnostic is triggered if `break` keyword is used outside of a loop.
+// This diagnostic is triggered if the `break` keyword is used outside of a loop.
 #[derive(Debug)]
 pub struct BreakOutsideOfLoop {
    pub file: HirFileId,
@@ -271,7 +271,7 @@ impl Diagnostic for BreakOutsideOfLoop {
 // Diagnostic: missing-unsafe
 //
-// This diagnostic is triggered if operation marked as `unsafe` is used outside of `unsafe` function or block.
+// This diagnostic is triggered if an operation marked as `unsafe` is used outside of an `unsafe` function or block.
 #[derive(Debug)]
 pub struct MissingUnsafe {
    pub file: HirFileId,
@@ -295,7 +295,7 @@ impl Diagnostic for MissingUnsafe {
 // Diagnostic: mismatched-arg-count
 //
-// This diagnostic is triggered if function is invoked with an incorrect amount of arguments.
+// This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
 #[derive(Debug)]
 pub struct MismatchedArgCount {
    pub file: HirFileId,
@@ -347,7 +347,7 @@ impl fmt::Display for CaseType {
 // Diagnostic: incorrect-ident-case
 //
-// This diagnostic is triggered if item name doesn't follow https://doc.rust-lang.org/1.0.0/style/style/naming/README.html[Rust naming convention].
+// This diagnostic is triggered if an item name doesn't follow https://doc.rust-lang.org/1.0.0/style/style/naming/README.html[Rust naming convention].
 #[derive(Debug)]
 pub struct IncorrectCase {
    pub file: HirFileId,
@@ -386,6 +386,31 @@ impl Diagnostic for IncorrectCase {
    }
 }
+// Diagnostic: replace-filter-map-next-with-find-map
+//
+// This diagnostic is triggered when `.filter_map(..).next()` is used, rather than the more concise `.find_map(..)`.
+#[derive(Debug)]
+pub struct ReplaceFilterMapNextWithFindMap {
+    pub file: HirFileId,
+    /// This expression is the whole method chain up to and including `.filter_map(..).next()`.
+    pub next_expr: AstPtr<ast::Expr>,
+}
+impl Diagnostic for ReplaceFilterMapNextWithFindMap {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("replace-filter-map-next-with-find-map")
+    }
+    fn message(&self) -> String {
+        "replace filter_map(..).next() with find_map(..)".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.next_expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
 #[cfg(test)]
 mod tests {
    use base_db::{fixture::WithFixture, FileId, SourceDatabase, SourceDatabaseExt};
@@ -644,4 +669,87 @@ fn foo() { break; }
            "#,
        );
    }
+    // Register the required standard library types to make the tests work
+    fn add_filter_map_with_find_next_boilerplate(body: &str) -> String {
+        let prefix = r#"
+        //- /main.rs crate:main deps:core
+        use core::iter::Iterator;
+        use core::option::Option::{self, Some, None};
+        "#;
+        let suffix = r#"
+        //- /core/lib.rs crate:core
+        pub mod option {
+            pub enum Option<T> { Some(T), None }
+        }
+        pub mod iter {
+            pub trait Iterator {
+                type Item;
+                fn filter_map<B, F>(self, f: F) -> FilterMap where F: FnMut(Self::Item) -> Option<B> { FilterMap }
+                fn next(&mut self) -> Option<Self::Item>;
+            }
+            pub struct FilterMap {}
+            impl Iterator for FilterMap {
+                type Item = i32;
+                fn next(&mut self) -> i32 { 7 }
+            }
+        }
+        "#;
+        format!("{}{}{}", prefix, body, suffix)
+    }
+    #[test]
+    fn replace_filter_map_next_with_find_map2() {
+        check_diagnostics(&add_filter_map_with_find_next_boilerplate(
+            r#"
+            fn foo() {
+                let m = [1, 2, 3].iter().filter_map(|x| if *x == 2 { Some (4) } else { None }).next();
+                      //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ replace filter_map(..).next() with find_map(..)
+            }
+        "#,
+        ));
+    }
+    #[test]
+    fn replace_filter_map_next_with_find_map_no_diagnostic_without_next() {
+        check_diagnostics(&add_filter_map_with_find_next_boilerplate(
+            r#"
+            fn foo() {
+                let m = [1, 2, 3]
+                    .iter()
+                    .filter_map(|x| if *x == 2 { Some (4) } else { None })
+                    .len();
+            }
+            "#,
+        ));
+    }
+    #[test]
+    fn replace_filter_map_next_with_find_map_no_diagnostic_with_intervening_methods() {
+        check_diagnostics(&add_filter_map_with_find_next_boilerplate(
+            r#"
+            fn foo() {
+                let m = [1, 2, 3]
+                    .iter()
+                    .filter_map(|x| if *x == 2 { Some (4) } else { None })
+                    .map(|x| x + 2)
+                    .len();
+            }
+            "#,
+        ));
+    }
+    #[test]
+    fn replace_filter_map_next_with_find_map_no_diagnostic_if_not_in_chain() {
+        check_diagnostics(&add_filter_map_with_find_next_boilerplate(
+            r#"
+            fn foo() {
+                let m = [1, 2, 3]
+                    .iter()
+                    .filter_map(|x| if *x == 2 { Some (4) } else { None });
+                let n = m.next();
+            }
+            "#,
+        ));
+    }
 }
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 107417c27..d740b7265 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -2,8 +2,10 @@
 use std::sync::Arc;
-use hir_def::{expr::Statement, path::path, resolver::HasResolver, AdtId, DefWithBodyId};
+use hir_def::{
-use hir_expand::diagnostics::DiagnosticSink;
+    expr::Statement, path::path, resolver::HasResolver, AdtId, AssocItemId, DefWithBodyId,
+};
+use hir_expand::{diagnostics::DiagnosticSink, name};
 use rustc_hash::FxHashSet;
 use syntax::{ast, AstPtr};
@@ -24,6 +26,8 @@ pub(crate) use hir_def::{
    LocalFieldId, VariantId,
 };
+use super::ReplaceFilterMapNextWithFindMap;
 pub(super) struct ExprValidator<'a, 'b: 'a> {
    owner: DefWithBodyId,
    infer: Arc<InferenceResult>,
@@ -40,6 +44,8 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
    }
    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
+        self.check_for_filter_map_next(db);
        let body = db.body(self.owner.into());
        for (id, expr) in body.exprs.iter() {
@@ -150,20 +156,76 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        }
    }
-    fn validate_call(&mut self, db: &dyn HirDatabase, call_id: ExprId, expr: &Expr) -> Option<()> {
+    fn check_for_filter_map_next(&mut self, db: &dyn HirDatabase) {
+        // Find the FunctionIds for Iterator::filter_map and Iterator::next
+        let iterator_path = path![core::iter::Iterator];
+        let resolver = self.owner.resolver(db.upcast());
+        let iterator_trait_id = match resolver.resolve_known_trait(db.upcast(), &iterator_path) {
+            Some(id) => id,
+            None => return,
+        };
+        let iterator_trait_items = &db.trait_data(iterator_trait_id).items;
+        let filter_map_function_id =
+            match iterator_trait_items.iter().find(|item| item.0 == name![filter_map]) {
+                Some((_, AssocItemId::FunctionId(id))) => id,
+                _ => return,
+            };
+        let next_function_id = match iterator_trait_items.iter().find(|item| item.0 == name![next])
+        {
+            Some((_, AssocItemId::FunctionId(id))) => id,
+            _ => return,
+        };
+        // Search function body for instances of .filter_map(..).next()
+        let body = db.body(self.owner.into());
+        let mut prev = None;
+        for (id, expr) in body.exprs.iter() {
+            if let Expr::MethodCall { receiver, .. } = expr {
+                let function_id = match self.infer.method_resolution(id) {
+                    Some(id) => id,
+                    None => continue,
+                };
+                if function_id == *filter_map_function_id {
+                    prev = Some(id);
+                    continue;
+                }
+                if function_id == *next_function_id {
+                    if let Some(filter_map_id) = prev {
+                        if *receiver == filter_map_id {
+                            let (_, source_map) = db.body_with_source_map(self.owner.into());
+                            if let Ok(next_source_ptr) = source_map.expr_syntax(id) {
+                                self.sink.push(ReplaceFilterMapNextWithFindMap {
+                                    file: next_source_ptr.file_id,
+                                    next_expr: next_source_ptr.value,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            prev = None;
+        }
+    }
+    fn validate_call(&mut self, db: &dyn HirDatabase, call_id: ExprId, expr: &Expr) {
        // Check that the number of arguments matches the number of parameters.
        // FIXME: Due to shortcomings in the current type system implementation, only emit this
        // diagnostic if there are no type mismatches in the containing function.
        if self.infer.type_mismatches.iter().next().is_some() {
-            return None;
+            return;
        }
        let is_method_call = matches!(expr, Expr::MethodCall { .. });
        let (sig, args) = match expr {
            Expr::Call { callee, args } => {
                let callee = &self.infer.type_of_expr[*callee];
-                let sig = callee.callable_sig(db)?;
+                let sig = match callee.callable_sig(db) {
+                    Some(sig) => sig,
+                    None => return,
+                };
                (sig, args.clone())
            }
            Expr::MethodCall { receiver, args, .. } => {
@@ -175,22 +237,25 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                    // if the receiver is of unknown type, it's very likely we
                    // don't know enough to correctly resolve the method call.
                    // This is kind of a band-aid for #6975.
-                    return None;
+                    return;
                }
                // FIXME: note that we erase information about substs here. This
                // is not right, but, luckily, doesn't matter as we care only
                // about the number of params
-                let callee = self.infer.method_resolution(call_id)?;
+                let callee = match self.infer.method_resolution(call_id) {
+                    Some(callee) => callee,
+                    None => return,
+                };
                let sig = db.callable_item_signature(callee.into()).value;
                (sig, args)
            }
-            _ => return None,
+            _ => return,
        };
        if sig.is_varargs {
-            return None;
+            return;
        }
        let params = sig.params();
@@ -213,8 +278,6 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                });
            }
        }
-        None
    }
    fn validate_match(
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index d2f1b4014..38a043c48 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -617,7 +617,7 @@ impl HirDisplay for FnSig {
 }
 fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> {
-    let krate = trait_.lookup(db).container.module(db).krate;
+    let krate = trait_.lookup(db).container.module(db).krate();
    let fn_traits = [
        db.lang_item(krate, "fn".into()),
        db.lang_item(krate, "fn_mut".into()),
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index e00c7e176..d47f975d2 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -211,19 +211,21 @@ impl TypeCtor {
            | TypeCtor::Tuple { .. } => None,
            // Closure's krate is irrelevant for coherence I would think?
            TypeCtor::Closure { .. } => None,
-            TypeCtor::Adt(adt) => Some(adt.module(db.upcast()).krate),
+            TypeCtor::Adt(adt) => Some(adt.module(db.upcast()).krate()),
            TypeCtor::FnDef(callable) => Some(callable.krate(db)),
            TypeCtor::AssociatedType(type_alias) => {
-                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate)
+                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate())
            }
            TypeCtor::ForeignType(type_alias) => {
-                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate)
+                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate())
            }
            TypeCtor::OpaqueType(opaque_ty_id) => match opaque_ty_id {
                OpaqueTyId::ReturnTypeImplTrait(func, _) => {
-                    Some(func.lookup(db.upcast()).module(db.upcast()).krate)
+                    Some(func.lookup(db.upcast()).module(db.upcast()).krate())
+                }
+                OpaqueTyId::AsyncBlockTypeImplTrait(def, _) => {
+                    Some(def.module(db.upcast()).krate())
                }
-                OpaqueTyId::AsyncBlockTypeImplTrait(def, _) => Some(def.module(db.upcast()).krate),
            },
        }
    }
@@ -870,7 +872,7 @@ impl Ty {
            Ty::Apply(ApplicationTy { ctor: TypeCtor::OpaqueType(opaque_ty_id), .. }) => {
                match opaque_ty_id {
                    OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => {
-                        let krate = def.module(db.upcast()).krate;
+                        let krate = def.module(db.upcast()).krate();
                        if let Some(future_trait) = db
                            .lang_item(krate, "future_trait".into())
                            .and_then(|item| item.as_trait())
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 7a734c8b9..dfb573ff3 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -1147,7 +1147,7 @@ impl CallableDefId {
            CallableDefId::StructId(s) => s.lookup(db).container.module(db),
            CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container.module(db),
        }
-        .krate
+        .krate()
    }
 }
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index f06aeeb42..a302456b0 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -248,12 +248,12 @@ impl Ty {
        let lang_item_targets = match self {
            Ty::Apply(a_ty) => match a_ty.ctor {
                TypeCtor::Adt(def_id) => {
-                    return Some(std::iter::once(def_id.module(db.upcast()).krate).collect())
+                    return Some(std::iter::once(def_id.module(db.upcast()).krate()).collect())
                }
                TypeCtor::ForeignType(type_alias_id) => {
                    return Some(
                        std::iter::once(
-                            type_alias_id.lookup(db.upcast()).module(db.upcast()).krate,
+                            type_alias_id.lookup(db.upcast()).module(db.upcast()).krate(),
                        )
                        .collect(),
                    )
@@ -280,7 +280,7 @@ impl Ty {
                LangItemTarget::ImplDefId(it) => Some(it),
                _ => None,
            })
-            .map(|it| it.lookup(db.upcast()).container.module(db.upcast()).krate)
+            .map(|it| it.lookup(db.upcast()).container.module(db.upcast()).krate())
            .collect();
        Some(res)
    }
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
index 3bbcbc242..381b98ba8 100644
--- a/crates/hir_ty/src/test_db.rs
+++ b/crates/hir_ty/src/test_db.rs
@@ -83,7 +83,7 @@ impl TestDB {
            let crate_def_map = self.crate_def_map(krate);
            for (local_id, data) in crate_def_map.modules() {
                if data.origin.file_id() == Some(file_id) {
-                    return ModuleId { krate, local_id };
+                    return crate_def_map.module_id(local_id);
                }
            }
        }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 4a3fcea8d..7386a4e7b 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -188,10 +188,10 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
    };
    let module = db.module_for_file(file_id);
-    let crate_def_map = db.crate_def_map(module.krate);
+    let def_map = module.def_map(&db);
    let mut defs: Vec<DefWithBodyId> = Vec::new();
-    visit_module(&db, &crate_def_map, module.local_id, &mut |it| defs.push(it));
+    visit_module(&db, &def_map, module.local_id, &mut |it| defs.push(it));
    defs.sort_by_key(|def| match def {
        DefWithBodyId::FunctionId(it) => {
            let loc = it.lookup(&db);
@@ -321,7 +321,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
    {
        let events = db.log_executed(|| {
            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = db.crate_def_map(module.krate);
+            let crate_def_map = module.def_map(&db);
            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
                db.infer(def);
            });
@@ -343,7 +343,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
    {
        let events = db.log_executed(|| {
            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = db.crate_def_map(module.krate);
+            let crate_def_map = module.def_map(&db);
            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
                db.infer(def);
            });
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 2196af677..cfb756158 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -426,7 +426,7 @@ pub(crate) fn trait_datum_query(
    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let flags = rust_ir::TraitFlags {
        auto: trait_data.auto,
-        upstream: trait_.lookup(db.upcast()).container.module(db.upcast()).krate != krate,
+        upstream: trait_.lookup(db.upcast()).container.module(db.upcast()).krate() != krate,
        non_enumerable: true,
        coinductive: false, // only relevant for Chalk testing
        // FIXME: set these flags correctly
@@ -549,7 +549,7 @@ fn impl_def_datum(
    let generic_params = generics(db.upcast(), impl_id.into());
    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let trait_ = trait_ref.trait_;
-    let impl_type = if impl_id.lookup(db.upcast()).container.module(db.upcast()).krate == krate {
+    let impl_type = if impl_id.lookup(db.upcast()).container.module(db.upcast()).krate() == krate {
        rust_ir::ImplType::Local
    } else {
        rust_ir::ImplType::External
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index b35bc2bae..8607139ba 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -136,6 +136,9 @@ pub(crate) fn diagnostics(
        .on::<hir::diagnostics::IncorrectCase, _>(|d| {
            res.borrow_mut().push(warning_with_fix(d, &sema));
        })
+        .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
+            res.borrow_mut().push(warning_with_fix(d, &sema));
+        })
        .on::<hir::diagnostics::InactiveCode, _>(|d| {
            // If there's inactive code somewhere in a macro, don't propagate to the call-site.
            if d.display_source().file_id.expansion_info(db).is_some() {
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 579d5a308..cbfc66ab3 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -4,7 +4,7 @@ use hir::{
    db::AstDatabase,
    diagnostics::{
        Diagnostic, IncorrectCase, MissingFields, MissingOkOrSomeInTailExpr, NoSuchField,
-        RemoveThisSemicolon, UnresolvedModule,
+        RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap, UnresolvedModule,
    },
    HasSource, HirDisplay, InFile, Semantics, VariantDef,
 };
@@ -15,8 +15,8 @@ use ide_db::{
 };
 use syntax::{
    algo,
-    ast::{self, edit::IndentLevel, make},
+    ast::{self, edit::IndentLevel, make, ArgListOwner},
-    AstNode,
+    AstNode, TextRange,
 };
 use text_edit::TextEdit;
@@ -144,6 +144,33 @@ impl DiagnosticWithFix for IncorrectCase {
    }
 }
+impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
+    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let next_expr = self.next_expr.to_node(&root);
+        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
+        let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?;
+        let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range();
+        let filter_map_args = filter_map_call.arg_list()?;
+        let range_to_replace =
+            TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end());
+        let replacement = format!("find_map{}", filter_map_args.syntax().text());
+        let trigger_range = next_expr.syntax().text_range();
+        let edit = TextEdit::replace(range_to_replace, replacement);
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
+        Some(Fix::new(
+            "Replace filter_map(..).next() with find_map()",
+            source_change,
+            trigger_range,
+        ))
+    }
+}
 fn missing_record_expr_field_fix(
    sema: &Semantics<RootDatabase>,
    usage_file_id: FileId,
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 9c568c90c..23d885218 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -7,6 +7,7 @@ use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, Mo
 use ide_db::{
    base_db::{FileId, FileRange, SourceDatabase},
    symbol_index::FileSymbolKind,
+    SymbolKind,
 };
 use ide_db::{defs::Definition, RootDatabase};
 use syntax::{
@@ -18,30 +19,6 @@ use crate::FileSymbol;
 use super::short_label::ShortLabel;
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum SymbolKind {
-    Module,
-    Impl,
-    Field,
-    TypeParam,
-    ConstParam,
-    LifetimeParam,
-    ValueParam,
-    SelfParam,
-    Local,
-    Label,
-    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.
 ///
@@ -196,6 +173,7 @@ impl ToNav for FileSymbol {
                FileSymbolKind::Const => SymbolKind::Const,
                FileSymbolKind::Static => SymbolKind::Static,
                FileSymbolKind::Macro => SymbolKind::Macro,
+                FileSymbolKind::Union => SymbolKind::Union,
            }),
            full_range: self.range,
            focus_range: self.name_range,
@@ -457,13 +435,16 @@ impl TryToNav for hir::TypeParam {
    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
        let src = self.source(db)?;
        let full_range = match &src.value {
-            Either::Left(it) => it.syntax().text_range(),
+            Either::Left(it) => it
+                .name()
+                .map_or_else(|| it.syntax().text_range(), |name| name.syntax().text_range()),
            Either::Right(it) => it.syntax().text_range(),
        };
        let focus_range = match &src.value {
-            Either::Left(_) => None,
+            Either::Left(it) => it.name(),
-            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
+            Either::Right(it) => it.name(),
-        };
+        }
+        .map(|it| it.syntax().text_range());
        Some(NavigationTarget {
            file_id: src.file_id.original_file(db),
            name: self.name(db).to_string().into(),
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index 32556dad3..26793bdb4 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -1,10 +1,9 @@
+use ide_db::SymbolKind;
 use syntax::{
    ast::{self, AttrsOwner, GenericParamsOwner, NameOwner},
    match_ast, AstNode, SourceFile, SyntaxNode, TextRange, WalkEvent,
 };
-use crate::SymbolKind;
 #[derive(Debug, Clone)]
 pub struct StructureNode {
    pub parent: Option<usize>,
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 567b8117e..989e94a31 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -65,7 +65,7 @@ use crate::display::ToNav;
 pub use crate::{
    call_hierarchy::CallItem,
    diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
-    display::navigation_target::{NavigationTarget, SymbolKind},
+    display::navigation_target::NavigationTarget,
    expand_macro::ExpandedMacro,
    file_structure::StructureNode,
    folding_ranges::{Fold, FoldKind},
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 3a4f4d80b..40d9487eb 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -1098,4 +1098,20 @@ fn foo<const FOO$0: usize>() -> usize {
            "#]],
        );
    }
+    #[test]
+    fn test_find_self_ty_in_trait_def() {
+        check(
+            r#"
+trait Foo {
+    fn f() -> Self$0;
+}
+"#,
+            expect![[r#"
+                Self TypeParam FileId(0) 6..9 6..9 Other
+                FileId(0) 26..30 Other
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 975abf47f..33170906d 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
 use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
-use ide_db::{defs::Definition, RootDatabase};
+use ide_db::{defs::Definition, RootDatabase, SymbolKind};
 use itertools::Itertools;
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
@@ -13,7 +13,7 @@ use test_utils::mark;
 use crate::{
    display::{ToNav, TryToNav},
-    FileId, NavigationTarget, SymbolKind,
+    FileId, NavigationTarget,
 };
 #[derive(Debug, Clone)]
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index f2d4da78d..a3d4e4f77 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -13,7 +13,7 @@ mod html;
 mod tests;
 use hir::{Name, Semantics};
-use ide_db::RootDatabase;
+use ide_db::{RootDatabase, SymbolKind};
 use rustc_hash::FxHashMap;
 use syntax::{
    ast::{self, HasFormatSpecifier},
@@ -27,7 +27,7 @@ use crate::{
        format::highlight_format_string, highlights::Highlights,
        macro_rules::MacroRulesHighlighter, tags::Highlight,
    },
-    FileId, HlMod, HlTag, SymbolKind,
+    FileId, HlMod, HlTag,
 };
 pub(crate) use html::highlight_as_html;
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 8a9b5ca8c..8c67a0863 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -1,10 +1,11 @@
 //! Syntax highlighting for format macro strings.
+use ide_db::SymbolKind;
 use syntax::{
    ast::{self, FormatSpecifier, HasFormatSpecifier},
    AstNode, AstToken, TextRange,
 };
-use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag, SymbolKind};
+use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag};
 pub(super) fn highlight_format_string(
    stack: &mut Highlights,
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 8625ef5df..24fcbb584 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -3,7 +3,7 @@
 use hir::{AsAssocItem, Semantics, VariantDef};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
-    RootDatabase,
+    RootDatabase, SymbolKind,
 };
 use rustc_hash::FxHashMap;
 use syntax::{
@@ -12,7 +12,7 @@ use syntax::{
    SyntaxNode, SyntaxToken, T,
 };
-use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag, SymbolKind};
+use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag};
 pub(super) fn element(
    sema: &Semantics<RootDatabase>,
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 8dd05ac52..3c02fdb11 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -3,7 +3,7 @@
 use std::{fmt, ops};
-use crate::SymbolKind;
+use ide_db::SymbolKind;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Highlight {
diff --git a/crates/ide_db/src/lib.rs b/crates/ide_db/src/lib.rs
index 118c090d7..6eb34b06b 100644
--- a/crates/ide_db/src/lib.rs
+++ b/crates/ide_db/src/lib.rs
@@ -134,3 +134,27 @@ fn line_index(db: &dyn LineIndexDatabase, file_id: FileId) -> Arc<LineIndex> {
    let text = db.file_text(file_id);
    Arc::new(LineIndex::new(&*text))
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SymbolKind {
+    Const,
+    ConstParam,
+    Enum,
+    Field,
+    Function,
+    Impl,
+    Label,
+    LifetimeParam,
+    Local,
+    Macro,
+    Module,
+    SelfParam,
+    Static,
+    Struct,
+    Trait,
+    TypeAlias,
+    TypeParam,
+    Union,
+    ValueParam,
+    Variant,
+}
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index e954bd72e..9ed9568ce 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -356,15 +356,16 @@ pub struct FileSymbol {
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
 pub enum FileSymbolKind {
+    Const,
+    Enum,
    Function,
+    Macro,
+    Module,
+    Static,
    Struct,
-    Enum,
    Trait,
-    Module,
    TypeAlias,
-    Const,
+    Union,
-    Static,
-    Macro,
 }
 impl FileSymbolKind {
@@ -375,6 +376,7 @@ impl FileSymbolKind {
                | FileSymbolKind::Enum
                | FileSymbolKind::Trait
                | FileSymbolKind::TypeAlias
+                | FileSymbolKind::Union
        )
    }
 }
@@ -425,6 +427,7 @@ fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
            ast::Const(it) => decl(it),
            ast::Static(it) => decl(it),
            ast::MacroRules(it) => decl(it),
+            ast::Union(it) => decl(it),
            _ => None,
        }
    }
@@ -443,6 +446,7 @@ fn to_file_symbol(node: &SyntaxNode, file_id: FileId) -> Option<FileSymbol> {
            CONST => FileSymbolKind::Const,
            STATIC => FileSymbolKind::Static,
            MACRO_RULES => FileSymbolKind::Macro,
+            UNION => FileSymbolKind::Union,
            kind => unreachable!("{:?}", kind),
        },
        range: node.text_range(),
diff --git a/crates/ide_db/src/ty_filter.rs b/crates/ide_db/src/ty_filter.rs
index 63a945282..f8406851b 100644
--- a/crates/ide_db/src/ty_filter.rs
+++ b/crates/ide_db/src/ty_filter.rs
@@ -49,6 +49,21 @@ impl TryEnum {
        }
    }
+    pub fn happy_pattern(self) -> ast::Pat {
+        match self {
+            TryEnum::Result => make::tuple_struct_pat(
+                make::path_unqualified(make::path_segment(make::name_ref("Ok"))),
+                iter::once(make::wildcard_pat().into()),
+            )
+            .into(),
+            TryEnum::Option => make::tuple_struct_pat(
+                make::path_unqualified(make::path_segment(make::name_ref("Some"))),
+                iter::once(make::wildcard_pat().into()),
+            )
+            .into(),
+        }
+    }
    fn type_name(self) -> &'static str {
        match self {
            TryEnum::Result => "Result",
diff --git a/crates/parser/src/grammar/items/consts.rs b/crates/parser/src/grammar/items/consts.rs
index eb7d1f828..12130df40 100644
--- a/crates/parser/src/grammar/items/consts.rs
+++ b/crates/parser/src/grammar/items/consts.rs
@@ -13,7 +13,7 @@ pub(super) fn konst(p: &mut Parser, m: Marker) {
 fn const_or_static(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
    assert!(p.at(kw));
    p.bump(kw);
-    p.eat(T![mut]); // FIXME: validator to forbid const mut
+    p.eat(T![mut]);
    // Allow `_` in place of an identifier in a `const`.
    let is_const_underscore = kw == T![const] && p.eat(T![_]);
diff --git a/crates/profile/Cargo.toml b/crates/profile/Cargo.toml
index cc7da27f7..4dd9acc98 100644
--- a/crates/profile/Cargo.toml
+++ b/crates/profile/Cargo.toml
@@ -14,7 +14,7 @@ once_cell = "1.3.1"
 cfg-if = "1"
 libc = "0.2.73"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
-countme = { version = "2.0.0-pre.2", features = ["enable"] }
+countme = { version = "2.0.0", features = ["enable"] }
 jemalloc-ctl = { version = "0.3.3", optional = true }
 [target.'cfg(target_os = "linux")'.dependencies]
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 2f7f94a39..1d6e5478b 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -76,7 +76,12 @@ fn setup_logging(log_file: Option<PathBuf>) -> Result<()> {
    profile::init();
    if !cfg!(debug_assertions) {
-        stdx::set_assert_hook(|loc, args| log::error!("assertion failed at {}: {}", loc, args));
+        stdx::set_assert_hook(|loc, args| {
+            if env::var("RA_PROFILE").is_ok() {
+                panic!("assertion failed at {}: {}", loc, args)
+            }
+            log::error!("assertion failed at {}: {}", loc, args)
+        });
    }
    Ok(())
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 3ddb9e19a..247bfe71e 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -147,6 +147,9 @@ config_data! {
        /// Whether to show `Method References` lens. Only applies when
        /// `#rust-analyzer.lens.enable#` is set.
        lens_methodReferences: bool = "false",
+        /// Whether to show `References` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_references: bool = "false",
        /// Disable project auto-discovery in favor of explicitly specified set
        /// of projects.\n\nElements must be paths pointing to `Cargo.toml`,
@@ -221,6 +224,7 @@ pub struct LensConfig {
    pub debug: bool,
    pub implementations: bool,
    pub method_refs: bool,
+    pub refs: bool, // for Struct, Enum, Union and Trait
 }
 impl LensConfig {
@@ -237,7 +241,7 @@ impl LensConfig {
    }
    pub fn references(&self) -> bool {
-        self.method_refs
+        self.method_refs || self.refs
    }
 }
@@ -593,6 +597,7 @@ impl Config {
            debug: self.data.lens_enable && self.data.lens_debug,
            implementations: self.data.lens_enable && self.data.lens_implementations,
            method_refs: self.data.lens_enable && self.data.lens_methodReferences,
+            refs: self.data.lens_enable && self.data.lens_references,
        }
    }
    pub fn hover(&self) -> HoverConfig {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 42451cd2d..07204436c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -10,8 +10,9 @@ use std::{
 use ide::{
    FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData, LineIndex, NavigationTarget,
-    Query, RangeInfo, Runnable, RunnableKind, SearchScope, SourceChange, SymbolKind, TextEdit,
+    Query, RangeInfo, Runnable, RunnableKind, SearchScope, SourceChange, TextEdit,
 };
+use ide_db::SymbolKind;
 use itertools::Itertools;
 use lsp_server::ErrorCode;
 use lsp_types::{
@@ -1111,42 +1112,48 @@ pub(crate) fn handle_code_lens(
        }
    }
-    if lens_config.implementations {
+    if lens_config.implementations || lens_config.refs {
-        // Handle impls
+        snap.analysis
-        lenses.extend(
+            .file_structure(file_id)?
-            snap.analysis
+            .into_iter()
-                .file_structure(file_id)?
+            .filter(|it| {
-                .into_iter()
+                matches!(
-                .filter(|it| {
+                    it.kind,
-                    matches!(
+                    SymbolKind::Trait | SymbolKind::Struct | SymbolKind::Enum | SymbolKind::Union
-                        it.kind,
+                )
-                        SymbolKind::Trait
+            })
-                            | SymbolKind::Struct
+            .for_each(|it| {
-                            | SymbolKind::Enum
+                let range = to_proto::range(&line_index, it.node_range);
-                            | SymbolKind::Union
+                let position = to_proto::position(&line_index, it.navigation_range.start());
-                    )
+                let doc_pos = lsp_types::TextDocumentPositionParams::new(
-                })
+                    params.text_document.clone(),
-                .map(|it| {
+                    position,
-                    let range = to_proto::range(&line_index, it.node_range);
+                );
-                    let pos = range.start;
+                let goto_params = lsp_types::request::GotoImplementationParams {
-                    let lens_params = lsp_types::request::GotoImplementationParams {
+                    text_document_position_params: doc_pos.clone(),
-                        text_document_position_params: lsp_types::TextDocumentPositionParams::new(
+                    work_done_progress_params: Default::default(),
-                            params.text_document.clone(),
+                    partial_result_params: Default::default(),
-                            pos,
+                };
-                        ),
-                        work_done_progress_params: Default::default(),
+                if lens_config.implementations {
-                        partial_result_params: Default::default(),
+                    lenses.push(CodeLens {
-                    };
-                    CodeLens {
                        range,
                        command: None,
-                        data: Some(to_value(CodeLensResolveData::Impls(lens_params)).unwrap()),
+                        data: Some(to_value(CodeLensResolveData::Impls(goto_params)).unwrap()),
-                    }
+                    })
-                }),
+                }
-        );
+                if lens_config.refs {
+                    lenses.push(CodeLens {
+                        range,
+                        command: None,
+                        data: Some(to_value(CodeLensResolveData::References(doc_pos)).unwrap()),
+                    })
+                }
+            });
    }
-    if lens_config.references() {
+    if lens_config.method_refs {
        lenses.extend(snap.analysis.find_all_methods(file_id)?.into_iter().map(|it| {
            let range = to_proto::range(&line_index, it.range);
            let position = to_proto::position(&line_index, it.range.start());
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 0e3550002..96f915f1c 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -8,8 +8,9 @@ use ide::{
    Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HlMod, HlPunct, HlRange, HlTag, Indel,
    InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess,
-    RenameError, Runnable, Severity, SourceChange, SymbolKind, TextEdit, TextRange, TextSize,
+    RenameError, Runnable, Severity, SourceChange, TextEdit, TextRange, TextSize,
 };
+use ide_db::SymbolKind;
 use itertools::Itertools;
 use crate::{
@@ -87,25 +88,35 @@ pub(crate) fn completion_item_kind(
    completion_item_kind: CompletionItemKind,
 ) -> lsp_types::CompletionItemKind {
    match completion_item_kind {
-        CompletionItemKind::Keyword => lsp_types::CompletionItemKind::Keyword,
+        CompletionItemKind::Attribute => lsp_types::CompletionItemKind::EnumMember,
-        CompletionItemKind::Snippet => lsp_types::CompletionItemKind::Snippet,
-        CompletionItemKind::Module => lsp_types::CompletionItemKind::Module,
-        CompletionItemKind::Function => lsp_types::CompletionItemKind::Function,
-        CompletionItemKind::Struct => lsp_types::CompletionItemKind::Struct,
-        CompletionItemKind::Enum => lsp_types::CompletionItemKind::Enum,
-        CompletionItemKind::EnumVariant => lsp_types::CompletionItemKind::EnumMember,
-        CompletionItemKind::BuiltinType => lsp_types::CompletionItemKind::Struct,
        CompletionItemKind::Binding => lsp_types::CompletionItemKind::Variable,
-        CompletionItemKind::Field => lsp_types::CompletionItemKind::Field,
+        CompletionItemKind::BuiltinType => lsp_types::CompletionItemKind::Struct,
-        CompletionItemKind::Trait => lsp_types::CompletionItemKind::Interface,
+        CompletionItemKind::Keyword => lsp_types::CompletionItemKind::Keyword,
-        CompletionItemKind::TypeAlias => lsp_types::CompletionItemKind::Struct,
-        CompletionItemKind::Const => lsp_types::CompletionItemKind::Constant,
-        CompletionItemKind::Static => lsp_types::CompletionItemKind::Value,
        CompletionItemKind::Method => lsp_types::CompletionItemKind::Method,
-        CompletionItemKind::TypeParam => lsp_types::CompletionItemKind::TypeParameter,
+        CompletionItemKind::Snippet => lsp_types::CompletionItemKind::Snippet,
-        CompletionItemKind::Macro => lsp_types::CompletionItemKind::Method,
-        CompletionItemKind::Attribute => lsp_types::CompletionItemKind::EnumMember,
        CompletionItemKind::UnresolvedReference => lsp_types::CompletionItemKind::Reference,
+        CompletionItemKind::SymbolKind(symbol) => match symbol {
+            SymbolKind::Const => lsp_types::CompletionItemKind::Constant,
+            SymbolKind::ConstParam => lsp_types::CompletionItemKind::TypeParameter,
+            SymbolKind::Enum => lsp_types::CompletionItemKind::Enum,
+            SymbolKind::Field => lsp_types::CompletionItemKind::Field,
+            SymbolKind::Function => lsp_types::CompletionItemKind::Function,
+            SymbolKind::Impl => lsp_types::CompletionItemKind::Text,
+            SymbolKind::Label => lsp_types::CompletionItemKind::Variable,
+            SymbolKind::LifetimeParam => lsp_types::CompletionItemKind::TypeParameter,
+            SymbolKind::Local => lsp_types::CompletionItemKind::Variable,
+            SymbolKind::Macro => lsp_types::CompletionItemKind::Method,
+            SymbolKind::Module => lsp_types::CompletionItemKind::Module,
+            SymbolKind::SelfParam => lsp_types::CompletionItemKind::Value,
+            SymbolKind::Static => lsp_types::CompletionItemKind::Value,
+            SymbolKind::Struct => lsp_types::CompletionItemKind::Struct,
+            SymbolKind::Trait => lsp_types::CompletionItemKind::Interface,
+            SymbolKind::TypeAlias => lsp_types::CompletionItemKind::Struct,
+            SymbolKind::TypeParam => lsp_types::CompletionItemKind::TypeParameter,
+            SymbolKind::Union => lsp_types::CompletionItemKind::Struct,
+            SymbolKind::ValueParam => lsp_types::CompletionItemKind::Value,
+            SymbolKind::Variant => lsp_types::CompletionItemKind::EnumMember,
+        },
    }
 }
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 73b121f8a..d42817078 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -196,6 +196,7 @@ impl ops::DerefMut for JodChild {
 impl Drop for JodChild {
    fn drop(&mut self) {
        let _ = self.0.kill();
+        let _ = self.0.wait();
    }
 }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 24298fbfa..e70fbba9c 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 itertools = "0.10.0"
-rowan = "0.12"
+rowan = "0.12.2"
 rustc_lexer = { version = "700.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 7694e8834..3e216fb70 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -1,4 +1,6 @@
-//! FIXME: write short doc here
+//! This module implements syntax validation that the parser doesn't handle.
+//!
+//! A failed validation emits a diagnostic.
 mod block;
@@ -92,6 +94,7 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
        match_ast! {
            match node {
                ast::Literal(it) => validate_literal(it, &mut errors),
+                ast::Const(it) => validate_const(it, &mut errors),
                ast::BlockExpr(it) => block::validate_block_expr(it, &mut errors),
                ast::FieldExpr(it) => validate_numeric_name(it.name_ref(), &mut errors),
                ast::RecordExprField(it) => validate_numeric_name(it.name_ref(), &mut errors),
@@ -362,3 +365,14 @@ fn validate_macro_rules(mac: ast::MacroRules, errors: &mut Vec<SyntaxError>) {
        ));
    }
 }
+fn validate_const(const_: ast::Const, errors: &mut Vec<SyntaxError>) {
+    if let Some(mut_token) = const_
+        .const_token()
+        .and_then(|t| t.next_token())
+        .and_then(|t| algo::skip_trivia_token(t, Direction::Next))
+        .filter(|t| t.kind() == T![mut])
+    {
+        errors.push(SyntaxError::new("const globals cannot be mutable", mut_token.text_range()));
+    }
+}
diff --git a/crates/syntax/test_data/parser/err/0047_mutable_const_item.rast b/crates/syntax/test_data/parser/err/0047_mutable_const_item.rast
new file mode 100644
index 000000000..c7eb312c9
--- /dev/null
+++ b/crates/syntax/test_data/parser/err/0047_mutable_const_item.rast
@@ -0,0 +1,22 @@
+[email protected]
+  [email protected]
+    [email protected] "const"
+    [email protected] " "
+    [email protected] "mut"
+    [email protected] " "
+    [email protected]
+      [email protected] "FOO"
+    [email protected] ":"
+    [email protected] " "
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
+error 6..9: const globals cannot be mutable
diff --git a/crates/syntax/test_data/parser/err/0047_mutable_const_item.rs b/crates/syntax/test_data/parser/err/0047_mutable_const_item.rs
new file mode 100644
index 000000000..b34336f3f
--- /dev/null
+++ b/crates/syntax/test_data/parser/err/0047_mutable_const_item.rs
@@ -0,0 +1 @@
+const mut FOO: () = ();
diff --git a/crates/syntax/test_data/parser/ok/0024_const_item.rast b/crates/syntax/test_data/parser/ok/0024_const_item.rast
index dd1b9c9a0..b89ed6f98 100644
--- a/crates/syntax/test_data/parser/ok/0024_const_item.rast
+++ b/crates/syntax/test_data/parser/ok/0024_const_item.rast
@@ -1,4 +1,4 @@
-SOURCE_FILE@0..64
+SOURCE_FILE@0..39
  [email protected]
    [email protected] "const"
    [email protected] " "
@@ -36,24 +36,3 @@ [email protected]
      [email protected] "92"
    [email protected] ";"
  [email protected] "\n"
-  [email protected]
-    [email protected] "const"
-    [email protected] " "
-    [email protected] "mut"
-    [email protected] " "
-    [email protected]
-      [email protected] "BAR"
-    [email protected] ":"
-    [email protected] " "
-    [email protected]
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected] "u32"
-    [email protected] " "
-    [email protected] "="
-    [email protected] " "
-    [email protected]
-      [email protected] "62"
-    [email protected] ";"
-  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/ok/0024_const_item.rs b/crates/syntax/test_data/parser/ok/0024_const_item.rs
index a806a209d..1f2ffa0da 100644
--- a/crates/syntax/test_data/parser/ok/0024_const_item.rs
+++ b/crates/syntax/test_data/parser/ok/0024_const_item.rs
@@ -1,3 +1,2 @@
 const _: u32 = 0;
 const FOO: u32 = 92;
-const mut BAR: u32 = 62;