85 files changed, 1760 insertions, 1548 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 4476d188b..1051c4ec6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,9 +26,9 @@ dependencies = [
 [[package]]
 name = "anyhow"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c0df63cb2955042487fad3aefd2c6e3ae7389ac5dc1beb28921de0b69f779d4"
+checksum = "68803225a7b13e47191bab76f2687382b60d259e8cf37f6e1893658b84bb9479"
 [[package]]
 name = "anymap"
@@ -685,9 +685,9 @@ dependencies = [
 [[package]]
 name = "indexmap"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
+checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
 dependencies = [
 "autocfg",
 "hashbrown",
@@ -844,9 +844,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.85.0"
+version = "0.86.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "857650f3e83fb62f89d15410414e0ed7d0735445020da398d37f65d20a5423b9"
+checksum = "f2a5c40d566f2704dac30859bca152217583fc94fd5b178d8baba915e1abd382"
 dependencies = [
 "base64",
 "bitflags",
@@ -1105,9 +1105,9 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 [[package]]
 name = "perf-event"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "273069d0b956939ba75e8b5663328b9b7f0dc2e262b3306c6be66c4d87e2240a"
+checksum = "b7a1c2678a77d65edf773bd900f5b87f0944ac3421949842a2c6a4efe42d6c66"
 dependencies = [
 "libc",
 "perf-event-open-sys",
@@ -1990,18 +1990,18 @@ dependencies = [
 [[package]]
 name = "xshell"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed0728d188f2ae530490b7d92435728aba53c6aed06d07e1951da9bd4c1d0798"
+checksum = "ed373ede30cea03e8c0af22f48ee1ba80efbf06fec8b4746977e6ee703878de0"
 dependencies = [
 "xshell-macros",
 ]
 [[package]]
 name = "xshell-macros"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "367f903cc3f8bc4f4b2400d47dfa6c9e3e121ffb51a30cf0fb67a72c0a0f9617"
+checksum = "7f6af9f8119104697b0105989a73c578ce33f922d9d6f3dae0e8ae3d538db321"
 [[package]]
 name = "xtask"
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 2e56bd7ff..030b9cd0c 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -1,7 +1,7 @@
 use std::iter;
 use either::Either;
-use hir::{AsName, EnumVariant, Module, ModuleDef, Name};
+use hir::{AsName, Module, ModuleDef, Name, Variant};
 use ide_db::helpers::{
    insert_use::{insert_use, ImportScope},
    mod_path_to_ast,
@@ -53,7 +53,7 @@ pub(crate) fn extract_struct_from_enum_variant(
            let variant_hir_name = variant_hir.name(ctx.db());
            let enum_module_def = ModuleDef::from(enum_hir);
            let usages =
-                Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir)).usages(&ctx.sema).all();
+                Definition::ModuleDef(ModuleDef::Variant(variant_hir)).usages(&ctx.sema).all();
            let mut visited_modules_set = FxHashSet::default();
            let current_module = enum_hir.module(ctx.db());
@@ -109,7 +109,7 @@ fn extract_field_list_if_applicable(
    }
 }
-fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool {
+fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Variant) -> bool {
    variant
        .parent_enum(db)
        .module(db)
@@ -119,7 +119,7 @@ fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &En
            // only check type-namespace
            hir::ScopeDef::ModuleDef(def) => matches!(def,
                ModuleDef::Module(_) | ModuleDef::Adt(_) |
-                ModuleDef::EnumVariant(_) | ModuleDef::Trait(_) |
+                ModuleDef::Variant(_) | ModuleDef::Trait(_) |
                ModuleDef::TypeAlias(_) | ModuleDef::BuiltinType(_)
            ),
            _ => false,
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index ef12ef0cf..cb60a3128 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -192,7 +192,7 @@ fn resolve_tuple_of_enum_def(
        .collect()
 }
-fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
+fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::Variant) -> Option<ast::Pat> {
    let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
diff --git a/crates/assists/src/handlers/fix_visibility.rs b/crates/assists/src/handlers/fix_visibility.rs
index c86720787..8558a8ff0 100644
--- a/crates/assists/src/handlers/fix_visibility.rs
+++ b/crates/assists/src/handlers/fix_visibility.rs
@@ -201,7 +201,7 @@ fn target_data_for_def(
            (vis_offset(syntax), in_file_source.value.visibility(), syntax.text_range(), file_id)
        }
        // Enum variants can't be private, we can't modify builtin types
-        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+        hir::ModuleDef::Variant(_) | hir::ModuleDef::BuiltinType(_) => return None,
    };
    Some((offset, current_visibility, target, target_file, target_name))
diff --git a/crates/assists/src/handlers/generate_function.rs b/crates/assists/src/handlers/generate_function.rs
index 758188a42..f4cf155b6 100644
--- a/crates/assists/src/handlers/generate_function.rs
+++ b/crates/assists/src/handlers/generate_function.rs
@@ -145,7 +145,7 @@ impl FunctionBuilder {
            self.type_params,
            self.params,
            fn_body,
-            Some(make::ret_type(make::ty("()"))),
+            Some(make::ret_type(make::ty_unit())),
        );
        let leading_ws;
        let trailing_ws;
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index 9b7d6c580..1ef6b5f48 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -19,7 +19,7 @@ use hir::{ModPath, ScopeDef, Type};
 use crate::{
    item::Builder,
    render::{
-        const_::render_const, enum_variant::render_enum_variant, function::render_fn,
+        const_::render_const, enum_variant::render_variant, function::render_fn,
        macro_::render_macro, render_field, render_resolution, render_tuple_field,
        type_alias::render_type_alias, RenderContext,
    },
@@ -120,20 +120,20 @@ impl Completions {
    pub(crate) fn add_qualified_enum_variant(
        &mut self,
        ctx: &CompletionContext,
-        variant: hir::EnumVariant,
+        variant: hir::Variant,
        path: ModPath,
    ) {
-        let item = render_enum_variant(RenderContext::new(ctx), None, None, variant, Some(path));
+        let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
        self.add(item);
    }
    pub(crate) fn add_enum_variant(
        &mut self,
        ctx: &CompletionContext,
-        variant: hir::EnumVariant,
+        variant: hir::Variant,
        local_name: Option<String>,
    ) {
-        let item = render_enum_variant(RenderContext::new(ctx), None, local_name, variant, None);
+        let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
        self.add(item);
    }
 }
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index acce2e7e7..19ce2482f 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -428,8 +428,8 @@ struct Test {}
                at Hash
                at PartialEq
                at PartialEq, Eq
-                at PartialEq, Eq, PartialOrd, Ord
                at PartialEq, PartialOrd
+                at PartialEq, Eq, PartialOrd, Ord
            "#]],
        );
    }
@@ -457,10 +457,10 @@ struct Test {}
                at Clone, Copy
                at Debug
                at Default
-                at Eq
-                at Eq, PartialOrd, Ord
                at Hash
+                at Eq
                at PartialOrd
+                at Eq, PartialOrd, Ord
            "#]],
        )
    }
@@ -472,14 +472,14 @@ struct Test {}
            expect![[r#"
                at allow(…)
                at automatically_derived
-                at cfg(…)
                at cfg_attr(…)
+                at cfg(…)
                at cold
                at deny(…)
                at deprecated = "…"
                at derive(…)
-                at doc = "…"
                at export_name = "…"
+                at doc = "…"
                at forbid(…)
                at ignore = "…"
                at inline(…)
@@ -518,15 +518,15 @@ struct Test {}
            expect![[r#"
                at allow(…)
                at automatically_derived
-                at cfg(…)
                at cfg_attr(…)
+                at cfg(…)
                at cold
                at crate_name = ""
                at deny(…)
                at deprecated = "…"
                at derive(…)
-                at doc = "…"
                at export_name = "…"
+                at doc = "…"
                at feature(…)
                at forbid(…)
                at global_allocator
@@ -538,8 +538,8 @@ struct Test {}
                at macro_export
                at macro_use
                at must_use = "…"
-                at no_implicit_prelude
                at no_link
+                at no_implicit_prelude
                at no_main
                at no_mangle
                at no_std
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
index c9875045a..551ef1771 100644
--- a/crates/completion/src/completions/dot.rs
+++ b/crates/completion/src/completions/dot.rs
@@ -82,8 +82,8 @@ impl S {
 fn foo(s: S) { s.<|> }
 "#,
            expect![[r#"
-                me bar() fn bar(&self)
                fd foo   u32
+                me bar() fn bar(&self)
            "#]],
        );
    }
@@ -98,8 +98,8 @@ impl S {
 }
 "#,
            expect![[r#"
-                me foo()     fn foo(self)
                fd the_field (u32,)
+                me foo()     fn foo(self)
            "#]],
        )
    }
@@ -114,8 +114,8 @@ impl A {
 }
 "#,
            expect![[r#"
-                me foo()     fn foo(&self)
                fd the_field (u32, i32)
+                me foo()     fn foo(&self)
            "#]],
        )
    }
@@ -147,8 +147,8 @@ mod inner {
 fn foo(a: inner::A) { a.<|> }
 "#,
            expect![[r#"
-                fd crate_field u32
                fd pub_field   u32
+                fd crate_field u32
                fd super_field u32
            "#]],
        );
diff --git a/crates/completion/src/completions/keyword.rs b/crates/completion/src/completions/keyword.rs
index 720349b9d..1859dec70 100644
--- a/crates/completion/src/completions/keyword.rs
+++ b/crates/completion/src/completions/keyword.rs
@@ -223,21 +223,21 @@ mod tests {
        check(
            r"m<|>",
            expect![[r#"
-                kw const
-                kw enum
-                kw extern
                kw fn
+                kw use
                kw impl
-                kw mod
-                kw pub
-                kw pub(crate)
-                kw static
-                kw struct
                kw trait
-                kw type
+                kw enum
+                kw struct
                kw union
+                kw mod
+                kw const
+                kw type
+                kw static
+                kw extern
                kw unsafe
-                kw use
+                kw pub(crate)
+                kw pub
            "#]],
        );
    }
@@ -247,23 +247,23 @@ mod tests {
        check(
            r"fn quux() { <|> }",
            expect![[r#"
-                kw const
-                kw extern
                kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw impl
                kw let
-                kw loop
-                kw match
                kw mod
-                kw return
+                kw const
-                kw static
-                kw trait
                kw type
+                kw static
+                kw extern
                kw unsafe
-                kw use
+                kw return
-                kw while
            "#]],
        );
    }
@@ -273,23 +273,23 @@ mod tests {
        check(
            r"fn quux() { if true { <|> } }",
            expect![[r#"
-                kw const
-                kw extern
                kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw impl
                kw let
-                kw loop
-                kw match
                kw mod
-                kw return
+                kw const
-                kw static
-                kw trait
                kw type
+                kw static
+                kw extern
                kw unsafe
-                kw use
+                kw return
-                kw while
            "#]],
        );
    }
@@ -299,25 +299,25 @@ mod tests {
        check(
            r#"fn quux() { if true { () } <|> }"#,
            expect![[r#"
-                kw const
-                kw else
-                kw else if
-                kw extern
                kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw impl
                kw let
-                kw loop
+                kw else
-                kw match
+                kw else if
                kw mod
-                kw return
+                kw const
-                kw static
-                kw trait
                kw type
+                kw static
+                kw extern
                kw unsafe
-                kw use
+                kw return
-                kw while
            "#]],
        );
        check_edit(
@@ -336,13 +336,13 @@ fn quux() -> i32 {
 }
 "#,
            expect![[r#"
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw loop
-                kw match
-                kw return
                kw unsafe
-                kw while
+                kw return
            "#]],
        );
    }
@@ -352,8 +352,8 @@ fn quux() -> i32 {
        check(
            r"trait My { <|> }",
            expect![[r#"
-                kw const
                kw fn
+                kw const
                kw type
                kw unsafe
            "#]],
@@ -365,12 +365,12 @@ fn quux() -> i32 {
        check(
            r"impl My { <|> }",
            expect![[r#"
-                kw const
                kw fn
-                kw pub
+                kw const
-                kw pub(crate)
                kw type
                kw unsafe
+                kw pub(crate)
+                kw pub
            "#]],
        );
    }
@@ -380,25 +380,25 @@ fn quux() -> i32 {
        check(
            r"fn my() { loop { <|> } }",
            expect![[r#"
-                kw break
-                kw const
-                kw continue
-                kw extern
                kw fn
+                kw use
+                kw impl
+                kw trait
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw impl
                kw let
-                kw loop
-                kw match
                kw mod
-                kw return
+                kw const
-                kw static
-                kw trait
                kw type
+                kw static
+                kw extern
                kw unsafe
-                kw use
+                kw continue
-                kw while
+                kw break
+                kw return
            "#]],
        );
    }
@@ -409,8 +409,8 @@ fn quux() -> i32 {
            r"unsafe <|>",
            expect![[r#"
                kw fn
-                kw impl
                kw trait
+                kw impl
            "#]],
        );
    }
@@ -421,8 +421,8 @@ fn quux() -> i32 {
            r"fn my_fn() { unsafe <|> }",
            expect![[r#"
                kw fn
-                kw impl
                kw trait
+                kw impl
            "#]],
        );
    }
@@ -542,12 +542,12 @@ pub mod future {
        check(
            r#"fn main() { let _ = <|> }"#,
            expect![[r#"
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw loop
-                kw match
                kw return
-                kw while
            "#]],
        )
    }
@@ -562,8 +562,8 @@ struct Foo {
 }
 "#,
            expect![[r#"
-                kw pub
                kw pub(crate)
+                kw pub
            "#]],
        )
    }
@@ -600,12 +600,12 @@ fn foo() {
 }
 "#,
            expect![[r#"
+                kw match
+                kw while
+                kw loop
                kw if
                kw if let
-                kw loop
-                kw match
                kw return
-                kw while
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/mod_.rs b/crates/completion/src/completions/mod_.rs
index c96f84171..f77864b77 100644
--- a/crates/completion/src/completions/mod_.rs
+++ b/crates/completion/src/completions/mod_.rs
@@ -170,8 +170,8 @@ mod tests {
            fn ignored_bar() {}
        "#,
            expect![[r#"
-                md bar;
                md foo;
+                md bar;
            "#]],
        );
    }
@@ -207,8 +207,8 @@ mod tests {
            fn ignored_bar() {}
        "#,
            expect![[r#"
-                md bar;
                md foo;
+                md bar;
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 4f63ff0ef..4d56731ec 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -23,7 +23,7 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                        def,
                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                            | hir::ModuleDef::EnumVariant(..)
+                            | hir::ModuleDef::Variant(..)
                            | hir::ModuleDef::Const(..)
                            | hir::ModuleDef::Module(..)
                    )
@@ -66,10 +66,10 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                st Bar
                en E
-                ev X   ()
                ct Z
+                st Bar
+                ev X   ()
                md m
            "#]],
        );
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index c8ba63cd3..d6db82a93 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -315,20 +315,20 @@ fn main() {
 }
 "#,
            expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                sn if    if expr {}
-                sn let   let
+                sn while while expr {}
-                sn letm  let mut
-                sn match match expr {}
                sn not   !expr
-                sn ok    Ok(expr)
                sn ref   &expr
                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
            "#]],
        );
    }
@@ -347,18 +347,18 @@ fn main() {
 }
 "#,
            expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                sn if    if expr {}
-                sn match match expr {}
+                sn while while expr {}
                sn not   !expr
-                sn ok    Ok(expr)
                sn ref   &expr
                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
            "#]],
        );
    }
@@ -373,17 +373,17 @@ fn main() {
 }
 "#,
            expect![[r#"
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
                sn box   Box::new(expr)
-                sn call  function(expr)
+                sn ok    Ok(expr)
+                sn some  Some(expr)
                sn dbg   dbg!(expr)
                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
                sn let   let
                sn letm  let mut
-                sn match match expr {}
-                sn ok    Ok(expr)
-                sn ref   &expr
-                sn refm  &mut expr
-                sn some  Some(expr)
            "#]],
        )
    }
@@ -398,20 +398,20 @@ fn main() {
 }
 "#,
            expect![[r#"
-                sn box   Box::new(expr)
-                sn call  function(expr)
-                sn dbg   dbg!(expr)
-                sn dbgr  dbg!(&expr)
                sn if    if expr {}
-                sn let   let
+                sn while while expr {}
-                sn letm  let mut
-                sn match match expr {}
                sn not   !expr
-                sn ok    Ok(expr)
                sn ref   &expr
                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
                sn some  Some(expr)
-                sn while while expr {}
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
index bc23bea3f..1300f00b2 100644
--- a/crates/completion/src/completions/qualified_path.rs
+++ b/crates/completion/src/completions/qualified_path.rs
@@ -199,22 +199,22 @@ use self::{foo::*, bar<|>};
        check_builtin(
            r#"fn main() { let _: <|> = 92; }"#,
            expect![[r#"
+                bt u32
                bt bool
-                bt char
+                bt u8
+                bt isize
+                bt u16
+                bt u64
+                bt u128
                bt f32
-                bt f64
                bt i128
                bt i16
-                bt i32
+                bt str
                bt i64
+                bt char
+                bt f64
+                bt i32
                bt i8
-                bt isize
-                bt str
-                bt u128
-                bt u16
-                bt u32
-                bt u64
-                bt u8
                bt usize
            "#]],
        );
@@ -279,8 +279,8 @@ struct Spam;
 use crate::Sp<|>
 "#,
            expect![[r#"
-                st Spam
                md foo
+                st Spam
            "#]],
        );
    }
@@ -296,8 +296,8 @@ struct Spam;
 use crate::{Sp<|>};
 "#,
            expect![[r#"
-                st Spam
                md foo
+                st Spam
            "#]],
        );
    }
@@ -330,8 +330,8 @@ enum E { Foo, Bar(i32) }
 fn foo() { let _ = E::<|> }
 "#,
            expect![[r#"
-                ev Bar(…) (i32)
                ev Foo    ()
+                ev Bar(…) (i32)
            "#]],
        );
    }
@@ -353,10 +353,10 @@ impl S {
 fn foo() { let _ = S::<|> }
 "#,
            expect![[r#"
-                ct C    const C: i32 = 42;
-                ta T    type T = i32;
                fn a()  fn a()
                me b(…) fn b(&self)
+                ct C    const C: i32 = 42;
+                ta T    type T = i32;
            "#]],
        );
    }
@@ -381,9 +381,9 @@ mod m {
 fn foo() { let _ = S::<|> }
 "#,
            expect![[r#"
+                fn public_method() pub(crate) fn public_method()
                ct PUBLIC_CONST    pub(crate) const PUBLIC_CONST: u32 = 1;
                ta PublicType      pub(crate) type PublicType = u32;
-                fn public_method() pub(crate) fn public_method()
            "#]],
        );
    }
@@ -503,14 +503,14 @@ trait Sub: Super {
 fn foo<T: Sub>() { T::<|> }
 "#,
            expect![[r#"
-                ct C2           const C2: ();
-                ct CONST        const CONST: u8;
                ta SubTy        type SubTy;
                ta Ty           type Ty;
-                fn func()       fn func()
+                ct C2           const C2: ();
-                me method(…)    fn method(&self)
                fn subfunc()    fn subfunc()
                me submethod(…) fn submethod(&self)
+                ct CONST        const CONST: u8;
+                fn func()       fn func()
+                me method(…)    fn method(&self)
            "#]],
        );
    }
@@ -543,12 +543,12 @@ impl<T> Sub for Wrap<T> {
 }
 "#,
            expect![[r#"
-                ct C2           const C2: () = ();
-                ct CONST        const CONST: u8 = 0;
                ta SubTy        type SubTy;
                ta Ty           type Ty;
+                ct CONST        const CONST: u8 = 0;
                fn func()       fn func()
                me method(…)    fn method(&self)
+                ct C2           const C2: () = ();
                fn subfunc()    fn subfunc()
                me submethod(…) fn submethod(&self)
            "#]],
@@ -567,8 +567,8 @@ impl T { fn bar() {} }
 fn main() { T::<|>; }
 "#,
            expect![[r#"
-                fn bar() fn bar()
                fn foo() fn foo()
+                fn bar() fn bar()
            "#]],
        );
    }
@@ -583,9 +583,9 @@ macro_rules! foo { () => {} }
 fn main() { let _ = crate::<|> }
        "#,
            expect![[r##"
+                fn main()  fn main()
                ma foo!(…) #[macro_export]
                macro_rules! foo
-                fn main()  fn main()
            "##]],
        );
    }
@@ -603,8 +603,8 @@ mod a {
 }
 "#,
            expect![[r#"
-                ct A
                md b
+                ct A
            "#]],
        );
    }
@@ -628,8 +628,8 @@ mod p {
 "#,
            expect![[r#"
                ct RIGHT_CONST
-                st RightType
                fn right_fn()  fn wrong_fn()
+                st RightType
            "#]],
        );
@@ -675,8 +675,8 @@ fn main() { m!(self::f<|>); }
 fn foo() {}
 "#,
            expect![[r#"
-                fn foo()  fn foo()
                fn main() fn main()
+                fn foo()  fn foo()
            "#]],
        );
    }
@@ -747,8 +747,8 @@ fn main() {
 }
 "#,
            expect![[r#"
-                fn foo(…) fn foo(a: i32, b: i32)
                fn main() fn main()
+                fn foo(…) fn foo(a: i32, b: i32)
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index eaa44c97d..91bf4a8ad 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -94,9 +94,9 @@ fn process(f: S) {
        check_snippet(
            test_code,
            expect![[r#"
-                fd ..Default::default()
                sn pd
                sn ppd
+                fd ..Default::default()
            "#]],
        );
    }
@@ -160,8 +160,8 @@ fn process(e: E) {
 }
 "#,
            expect![[r#"
-                fd bar ()
                fd foo u32
+                fd bar ()
            "#]],
        );
    }
diff --git a/crates/completion/src/completions/snippet.rs b/crates/completion/src/completions/snippet.rs
index 6f0c00078..842590130 100644
--- a/crates/completion/src/completions/snippet.rs
+++ b/crates/completion/src/completions/snippet.rs
@@ -105,9 +105,9 @@ mod tests {
 }
 "#,
            expect![[r#"
-                sn macro_rules
-                sn tfn (Test function)
                sn tmod (Test module)
+                sn tfn (Test function)
+                sn macro_rules
            "#]],
        )
    }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index e2fe44aff..c4e0d0669 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -266,10 +266,10 @@ impl Test for T {
 }
 "#,
            expect![["
+ta type TestType = \n\
 ct const TEST_CONST: u16 = \n\
 fn fn test()
-ta type TestType = \n\
+"]],
-            "]],
        );
    }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index b9315f6c0..099ffb4d4 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,7 +1,7 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 use either::Either;
-use hir::{Adt, ModuleDef, ScopeDef, Type};
+use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
 use ide_db::helpers::insert_use::ImportScope;
 use ide_db::imports_locator;
 use syntax::AstNode;
@@ -126,7 +126,7 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
    let anchor = ctx.name_ref_syntax.as_ref()?;
    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
-    let possible_imports = imports_locator::find_similar_imports(
+    let mut all_mod_paths = imports_locator::find_similar_imports(
        &ctx.sema,
        ctx.krate?,
        Some(100),
@@ -144,33 +144,65 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
        })
    })
    .filter(|(mod_path, _)| mod_path.len() > 1)
-    .filter_map(|(import_path, definition)| {
+    .collect::<Vec<_>>();
+    let user_input_lowercased = potential_import_name.to_lowercase();
+    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
+        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
+    });
+    acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
        render_resolution_with_import(
            RenderContext::new(ctx),
            ImportEdit { import_path, import_scope: import_scope.clone() },
            &definition,
        )
-    });
+    }));
-    acc.add_all(possible_imports);
    Some(())
 }
+fn compute_fuzzy_completion_order_key(
+    proposed_mod_path: &ModPath,
+    user_input_lowercased: &str,
+) -> usize {
+    mark::hit!(certain_fuzzy_order_test);
+    let proposed_import_name = match proposed_mod_path.segments.last() {
+        Some(name) => name.to_string().to_lowercase(),
+        None => return usize::MAX,
+    };
+    match proposed_import_name.match_indices(user_input_lowercased).next() {
+        Some((first_matching_index, _)) => first_matching_index,
+        None => usize::MAX,
+    }
+}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
    use test_utils::mark;
    use crate::{
-        test_utils::{check_edit, check_edit_with_config, completion_list},
+        test_utils::{check_edit, check_edit_with_config, completion_list_with_config},
        CompletionConfig, CompletionKind,
    };
    fn check(ra_fixture: &str, expect: Expect) {
-        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        check_with_config(CompletionConfig::default(), ra_fixture, expect);
+    }
+    fn check_with_config(config: CompletionConfig, ra_fixture: &str, expect: Expect) {
+        let actual = completion_list_with_config(config, ra_fixture, CompletionKind::Reference);
        expect.assert_eq(&actual)
    }
+    fn fuzzy_completion_config() -> CompletionConfig {
+        let mut completion_config = CompletionConfig::default();
+        completion_config
+            .active_resolve_capabilities
+            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
+        completion_config
+    }
    #[test]
    fn self_fulfilling_completion() {
        mark::check!(self_fulfilling_completion);
@@ -246,9 +278,9 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
            "#]],
        );
    }
@@ -268,8 +300,8 @@ fn quux() {
 }
 "#,
            expect![[r#"
-                bn a
                bn b      i32
+                bn a
                fn quux() fn quux()
            "#]],
        );
@@ -284,8 +316,8 @@ fn quux() {
 }
 "#,
            expect![[r#"
-                fn quux() fn quux()
                bn x
+                fn quux() fn quux()
            "#]],
        );
    }
@@ -326,9 +358,9 @@ fn main() {
        check(
            r#"struct S<T> { x: <|>}"#,
            expect![[r#"
-                st S<…>
                tp Self
                tp T
+                st S<…>
            "#]],
        );
    }
@@ -353,9 +385,9 @@ enum E {}
 fn quux() { <|> }
 "#,
            expect![[r#"
-                en E
                st S
                fn quux() fn quux()
+                en E
            "#]],
        );
    }
@@ -407,8 +439,8 @@ mod m {
 }
 "#,
            expect![[r#"
-                st Bar
                fn quux() fn quux()
+                st Bar
            "#]],
        );
    }
@@ -453,8 +485,8 @@ fn foo() {
        check(
            r#"impl S { fn foo(&self) { <|> } }"#,
            expect![[r#"
-                tp Self
                bn self &{unknown}
+                tp Self
            "#]],
        );
    }
@@ -473,9 +505,9 @@ use prelude::*;
 mod prelude { struct Option; }
 "#,
            expect![[r#"
-                st Option
                fn foo()  fn foo()
                md std
+                st Option
            "#]],
        );
    }
@@ -500,10 +532,10 @@ use prelude::*;
 mod prelude { struct String; }
 "#,
            expect![[r#"
-                st String
-                md core
                fn foo()  fn foo()
                md std
+                md core
+                st String
            "#]],
        );
    }
@@ -529,13 +561,13 @@ mod m2 {
 fn main() { let v = <|> }
 "#,
            expect![[r##"
-                ma bar!(…) macro_rules! bar
+                md m1
                ma baz!(…) #[macro_export]
                macro_rules! baz
-                ma foo!(…) macro_rules! foo
-                md m1
-                md m2
                fn main()  fn main()
+                md m2
+                ma bar!(…) macro_rules! bar
+                ma foo!(…) macro_rules! foo
            "##]],
        );
    }
@@ -548,8 +580,8 @@ macro_rules! foo { () => {} }
 fn foo() { <|> }
 "#,
            expect![[r#"
-                ma foo!(…) macro_rules! foo
                fn foo()   fn foo()
+                ma foo!(…) macro_rules! foo
            "#]],
        );
    }
@@ -562,8 +594,8 @@ macro_rules! foo { () => {} }
 fn main() { let x: <|> }
 "#,
            expect![[r#"
-                ma foo!(…) macro_rules! foo
                fn main()  fn main()
+                ma foo!(…) macro_rules! foo
            "#]],
        );
    }
@@ -576,8 +608,8 @@ macro_rules! foo { () => {} }
 fn main() { <|> }
 "#,
            expect![[r#"
-                ma foo!(…) macro_rules! foo
                fn main()  fn main()
+                ma foo!(…) macro_rules! foo
            "#]],
        );
    }
@@ -609,10 +641,10 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
            "#]],
        );
    }
@@ -628,10 +660,10 @@ fn quux(x: i32) {
 }
 ",
            expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
            "#]],
        );
    }
@@ -647,10 +679,10 @@ fn quux(x: i32) {
 }
 "#,
            expect![[r#"
-                ma m!(…)   macro_rules! m
-                fn quux(…) fn quux(x: i32)
-                bn x       i32
                bn y       i32
+                bn x       i32
+                fn quux(…) fn quux(x: i32)
+                ma m!(…)   macro_rules! m
            "#]],
        );
    }
@@ -664,8 +696,8 @@ use spam::Quux;
 fn main() { <|> }
 "#,
            expect![[r#"
-                ?? Quux
                fn main() fn main()
+                ?? Quux
            "#]],
        );
    }
@@ -681,10 +713,10 @@ fn main() {
 }
 "#,
            expect![[r#"
-                en Foo
                ev Foo::Bar  ()
                ev Foo::Baz  ()
                ev Foo::Quux ()
+                en Foo
            "#]],
        )
    }
@@ -701,10 +733,10 @@ fn main() {
 }
 "#,
            expect![[r#"
-                en Foo
                ev Foo::Bar  ()
                ev Foo::Baz  ()
                ev Foo::Quux ()
+                en Foo
            "#]],
        )
    }
@@ -717,10 +749,10 @@ enum Foo { Bar, Baz, Quux }
 fn main() { let foo: Foo = Q<|> }
 "#,
            expect![[r#"
-                en Foo
                ev Foo::Bar  ()
                ev Foo::Baz  ()
                ev Foo::Quux ()
+                en Foo
                fn main()    fn main()
            "#]],
        )
@@ -734,9 +766,9 @@ mod m { pub enum E { V } }
 fn f() -> m::E { V<|> }
 "#,
            expect![[r#"
-                fn f()     fn f() -> m::E
-                md m
                ev m::E::V ()
+                md m
+                fn f()     fn f() -> m::E
            "#]],
        )
    }
@@ -763,22 +795,17 @@ struct MyStruct {}
 impl My<|>
 "#,
            expect![[r#"
-                st MyStruct
-                tt MyTrait
                tp Self
+                tt MyTrait
+                st MyStruct
            "#]],
        )
    }
    #[test]
    fn function_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
        check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
            "stdin",
            r#"
 //- /lib.rs crate:dep
@@ -803,13 +830,8 @@ fn main() {
    #[test]
    fn macro_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
        check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
            "macro_with_curlies!",
            r#"
 //- /lib.rs crate:dep
@@ -836,13 +858,8 @@ fn main() {
    #[test]
    fn struct_fuzzy_completion() {
-        let mut completion_config = CompletionConfig::default();
-        completion_config
-            .active_resolve_capabilities
-            .insert(crate::CompletionResolveCapability::AdditionalTextEdits);
        check_edit_with_config(
-            completion_config,
+            fuzzy_completion_config(),
            "ThirdStruct",
            r#"
 //- /lib.rs crate:dep
@@ -868,4 +885,44 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn fuzzy_completions_come_in_specific_order() {
+        mark::check!(certain_fuzzy_order_test);
+        check_with_config(
+            fuzzy_completion_config(),
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    // already imported, omitted
+    pub struct SecondStruct;
+    // does not contain all letters from the query, omitted
+    pub struct UnrelatedOne;
+    // contains all letters from the query, but not in sequence, displayed last
+    pub struct ThiiiiiirdStruct;
+    // contains all letters from the query, but not in the beginning, displayed second
+    pub struct AfterThirdStruct;
+    // contains all letters from the query in the begginning, displayed first
+    pub struct ThirdStruct;
+}
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+fn main() {
+    hir<|>
+}
+"#,
+            expect![[r#"
+                fn main()           fn main()
+                st SecondStruct
+                st FirstStruct
+                md dep
+                st dep::some_module::ThirdStruct
+                st dep::some_module::AfterThirdStruct
+                st dep::some_module::ThiiiiiirdStruct
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index b940388df..1092a4825 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -19,7 +19,7 @@ use crate::{
    CompletionKind, CompletionScore,
 };
-use crate::render::{enum_variant::render_enum_variant, function::render_fn, macro_::render_macro};
+use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
 pub(crate) fn render_field<'a>(
    ctx: RenderContext<'a>,
@@ -159,9 +159,8 @@ impl<'a> Render<'a> {
                let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
                return Some(item);
            }
-            ScopeDef::ModuleDef(EnumVariant(var)) => {
+            ScopeDef::ModuleDef(Variant(var)) => {
-                let item =
+                let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
-                    render_enum_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                return Some(item);
            }
            ScopeDef::MacroDef(mac) => {
@@ -257,7 +256,7 @@ impl<'a> Render<'a> {
        match resolution {
            ScopeDef::ModuleDef(Module(it)) => it.docs(self.ctx.db()),
            ScopeDef::ModuleDef(Adt(it)) => it.docs(self.ctx.db()),
-            ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(self.ctx.db()),
+            ScopeDef::ModuleDef(Variant(it)) => it.docs(self.ctx.db()),
            ScopeDef::ModuleDef(Const(it)) => it.docs(self.ctx.db()),
            ScopeDef::ModuleDef(Static(it)) => it.docs(self.ctx.db()),
            ScopeDef::ModuleDef(Trait(it)) => it.docs(self.ctx.db()),
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 8e0fea6c0..7176fd9b3 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -9,35 +9,35 @@ use crate::{
    render::{builder_ext::Params, RenderContext},
 };
-pub(crate) fn render_enum_variant<'a>(
+pub(crate) fn render_variant<'a>(
    ctx: RenderContext<'a>,
    import_to_add: Option<ImportEdit>,
    local_name: Option<String>,
-    variant: hir::EnumVariant,
+    variant: hir::Variant,
    path: Option<ModPath>,
 ) -> CompletionItem {
    let _p = profile::span("render_enum_variant");
-    EnumVariantRender::new(ctx, local_name, variant, path).render(import_to_add)
+    EnumRender::new(ctx, local_name, variant, path).render(import_to_add)
 }
 #[derive(Debug)]
-struct EnumVariantRender<'a> {
+struct EnumRender<'a> {
    ctx: RenderContext<'a>,
    name: String,
-    variant: hir::EnumVariant,
+    variant: hir::Variant,
    path: Option<ModPath>,
    qualified_name: String,
    short_qualified_name: String,
    variant_kind: StructKind,
 }
-impl<'a> EnumVariantRender<'a> {
+impl<'a> EnumRender<'a> {
    fn new(
        ctx: RenderContext<'a>,
        local_name: Option<String>,
-        variant: hir::EnumVariant,
+        variant: hir::Variant,
        path: Option<ModPath>,
-    ) -> EnumVariantRender<'a> {
+    ) -> EnumRender<'a> {
        let name = local_name.unwrap_or_else(|| variant.name(ctx.db()).to_string());
        let variant_kind = variant.kind(ctx.db());
@@ -51,15 +51,7 @@ impl<'a> EnumVariantRender<'a> {
            None => (name.to_string(), name.to_string()),
        };
-        EnumVariantRender {
+        EnumRender { ctx, name, variant, path, qualified_name, short_qualified_name, variant_kind }
-            ctx,
-            name,
-            variant,
-            path,
-            qualified_name,
-            short_qualified_name,
-            variant_kind,
-        }
    }
    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index 6cfbd6c9b..dac79592f 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -41,6 +41,7 @@ impl<'a> MacroRender<'a> {
    fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
        // FIXME: Currently proc-macro do not have ast-node,
        // such that it does not have source
+        // more discussion: https://github.com/rust-analyzer/rust-analyzer/issues/6913
        if self.macro_.is_proc_macro() {
            return None;
        }
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index db896b2df..eb0c16f52 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -47,9 +47,8 @@ pub(crate) fn completion_list_with_config(
    code: &str,
    kind: CompletionKind,
 ) -> String {
-    let mut kind_completions: Vec<CompletionItem> =
+    let kind_completions: Vec<CompletionItem> =
        get_all_items(config, code).into_iter().filter(|c| c.completion_kind == kind).collect();
-    kind_completions.sort_by_key(|c| c.label().to_owned());
    let label_width = kind_completions
        .iter()
        .map(|it| monospace_width(it.label()))
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 1f2ee2580..d32ce37ed 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -10,8 +10,8 @@ use hir_ty::db::HirDatabase;
 use syntax::ast;
 use crate::{
-    Adt, Const, Enum, EnumVariant, Field, Function, MacroDef, Module, ModuleDef, Static, Struct,
+    Adt, Const, Enum, Field, Function, MacroDef, Module, ModuleDef, Static, Struct, Trait,
-    Trait, TypeAlias, Union,
+    TypeAlias, Union, Variant,
 };
 pub trait HasAttrs {
@@ -53,7 +53,7 @@ macro_rules! impl_has_attrs {
 impl_has_attrs![
    (Field, FieldId),
-    (EnumVariant, EnumVariantId),
+    (Variant, EnumVariantId),
    (Static, StaticId),
    (Const, ConstId),
    (Trait, TraitId),
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index afe229c32..73ca6ba9f 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -161,7 +161,7 @@ pub enum ModuleDef {
    Function(Function),
    Adt(Adt),
    // Can't be directly declared, but can be imported.
-    EnumVariant(EnumVariant),
+    Variant(Variant),
    Const(Const),
    Static(Static),
    Trait(Trait),
@@ -172,7 +172,7 @@ impl_from!(
    Module,
    Function,
    Adt(Struct, Enum, Union),
-    EnumVariant,
+    Variant,
    Const,
    Static,
    Trait,
@@ -186,7 +186,7 @@ impl From<VariantDef> for ModuleDef {
        match var {
            VariantDef::Struct(t) => Adt::from(t).into(),
            VariantDef::Union(t) => Adt::from(t).into(),
-            VariantDef::EnumVariant(t) => t.into(),
+            VariantDef::Variant(t) => t.into(),
        }
    }
 }
@@ -197,7 +197,7 @@ impl ModuleDef {
            ModuleDef::Module(it) => it.parent(db),
            ModuleDef::Function(it) => Some(it.module(db)),
            ModuleDef::Adt(it) => Some(it.module(db)),
-            ModuleDef::EnumVariant(it) => Some(it.module(db)),
+            ModuleDef::Variant(it) => Some(it.module(db)),
            ModuleDef::Const(it) => Some(it.module(db)),
            ModuleDef::Static(it) => Some(it.module(db)),
            ModuleDef::Trait(it) => Some(it.module(db)),
@@ -221,7 +221,7 @@ impl ModuleDef {
            ModuleDef::Module(it) => it.parent(db)?,
            ModuleDef::Function(it) => return Some(it.visibility(db)),
            ModuleDef::Adt(it) => it.module(db),
-            ModuleDef::EnumVariant(it) => {
+            ModuleDef::Variant(it) => {
                let parent = it.parent_enum(db);
                let module = it.module(db);
                return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)));
@@ -241,7 +241,7 @@ impl ModuleDef {
            ModuleDef::Adt(it) => Some(it.name(db)),
            ModuleDef::Trait(it) => Some(it.name(db)),
            ModuleDef::Function(it) => Some(it.name(db)),
-            ModuleDef::EnumVariant(it) => Some(it.name(db)),
+            ModuleDef::Variant(it) => Some(it.name(db)),
            ModuleDef::TypeAlias(it) => Some(it.name(db)),
            ModuleDef::Module(it) => it.name(db),
            ModuleDef::Const(it) => it.name(db),
@@ -455,7 +455,7 @@ impl Field {
        let generic_def_id: GenericDefId = match self.parent {
            VariantDef::Struct(it) => it.id.into(),
            VariantDef::Union(it) => it.id.into(),
-            VariantDef::EnumVariant(it) => it.parent.id.into(),
+            VariantDef::Variant(it) => it.parent.id.into(),
        };
        let substs = Substs::type_params(db, generic_def_id);
        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
@@ -566,12 +566,8 @@ impl Enum {
        db.enum_data(self.id).name.clone()
    }
-    pub fn variants(self, db: &dyn HirDatabase) -> Vec<EnumVariant> {
+    pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {
-        db.enum_data(self.id)
+        db.enum_data(self.id).variants.iter().map(|(id, _)| Variant { parent: self, id }).collect()
-            .variants
-            .iter()
-            .map(|(id, _)| EnumVariant { parent: self, id })
-            .collect()
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
@@ -580,12 +576,12 @@ impl Enum {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct EnumVariant {
+pub struct Variant {
    pub(crate) parent: Enum,
    pub(crate) id: LocalEnumVariantId,
 }
-impl EnumVariant {
+impl Variant {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
        self.parent.module(db)
    }
@@ -662,16 +658,16 @@ impl Adt {
 pub enum VariantDef {
    Struct(Struct),
    Union(Union),
-    EnumVariant(EnumVariant),
+    Variant(Variant),
 }
-impl_from!(Struct, Union, EnumVariant for VariantDef);
+impl_from!(Struct, Union, Variant for VariantDef);
 impl VariantDef {
    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
        match self {
            VariantDef::Struct(it) => it.fields(db),
            VariantDef::Union(it) => it.fields(db),
-            VariantDef::EnumVariant(it) => it.fields(db),
+            VariantDef::Variant(it) => it.fields(db),
        }
    }
@@ -679,7 +675,7 @@ impl VariantDef {
        match self {
            VariantDef::Struct(it) => it.module(db),
            VariantDef::Union(it) => it.module(db),
-            VariantDef::EnumVariant(it) => it.module(db),
+            VariantDef::Variant(it) => it.module(db),
        }
    }
@@ -687,7 +683,7 @@ impl VariantDef {
        match self {
            VariantDef::Struct(s) => s.name(db),
            VariantDef::Union(u) => u.name(db),
-            VariantDef::EnumVariant(e) => e.name(db),
+            VariantDef::Variant(e) => e.name(db),
        }
    }
@@ -695,7 +691,7 @@ impl VariantDef {
        match self {
            VariantDef::Struct(it) => it.variant_data(db),
            VariantDef::Union(it) => it.variant_data(db),
-            VariantDef::EnumVariant(it) => it.variant_data(db),
+            VariantDef::Variant(it) => it.variant_data(db),
        }
    }
 }
@@ -983,6 +979,12 @@ impl MacroDef {
    /// XXX: this parses the file
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        // FIXME: Currently proc-macro do not have ast-node,
+        // such that it does not have source
+        // more discussion: https://github.com/rust-analyzer/rust-analyzer/issues/6913
+        if self.is_proc_macro() {
+            return None;
+        }
        self.source(db).value.name().map(|it| it.as_name())
    }
@@ -1089,7 +1091,7 @@ pub enum GenericDef {
    Impl(Impl),
    // enum variants cannot have generics themselves, but their parent enums
    // can, and this makes some code easier to write
-    EnumVariant(EnumVariant),
+    Variant(Variant),
    // consts can have type parameters from their parents (i.e. associated consts of traits)
    Const(Const),
 }
@@ -1099,7 +1101,7 @@ impl_from!(
    Trait,
    TypeAlias,
    Impl,
-    EnumVariant,
+    Variant,
    Const
    for GenericDef
 );
@@ -1283,14 +1285,12 @@ impl Impl {
        impls.for_trait(trait_.id).map(Self::from).collect()
    }
+    // FIXME: the return type is wrong. This should be a hir version of
+    // `TraitRef` (ie, resolved `TypeRef`).
    pub fn target_trait(self, db: &dyn HirDatabase) -> Option<TypeRef> {
        db.impl_data(self.id).target_trait.clone()
    }
-    pub fn target_type(self, db: &dyn HirDatabase) -> TypeRef {
-        db.impl_data(self.id).target_type.clone()
-    }
    pub fn target_ty(self, db: &dyn HirDatabase) -> Type {
        let impl_data = db.impl_data(self.id);
        let resolver = self.id.resolver(db.upcast());
@@ -1324,6 +1324,7 @@ impl Impl {
        let item = src.file_id.is_builtin_derive(db.upcast())?;
        let hygenic = hir_expand::hygiene::Hygiene::new(db.upcast(), item.file_id);
+        // FIXME: handle `cfg_attr`
        let attr = item
            .value
            .attrs()
@@ -1841,7 +1842,7 @@ pub struct Callable {
 pub enum CallableKind {
    Function(Function),
    TupleStruct(Struct),
-    TupleEnumVariant(EnumVariant),
+    TupleEnumVariant(Variant),
    Closure,
 }
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 8d0f84508..8e0c571b8 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -9,8 +9,7 @@ use hir_def::{
 };
 use crate::{
-    Adt, AssocItem, DefWithBody, EnumVariant, Field, GenericDef, Local, MacroDef, ModuleDef,
+    Adt, AssocItem, DefWithBody, Field, GenericDef, Local, MacroDef, ModuleDef, Variant, VariantDef,
-    VariantDef,
 };
 macro_rules! from_id {
@@ -65,14 +64,14 @@ impl From<Adt> for AdtId {
    }
 }
-impl From<EnumVariantId> for EnumVariant {
+impl From<EnumVariantId> for Variant {
    fn from(id: EnumVariantId) -> Self {
-        EnumVariant { parent: id.parent.into(), id: id.local_id }
+        Variant { parent: id.parent.into(), id: id.local_id }
    }
 }
-impl From<EnumVariant> for EnumVariantId {
+impl From<Variant> for EnumVariantId {
-    fn from(def: EnumVariant) -> Self {
+    fn from(def: Variant) -> Self {
        EnumVariantId { parent: def.parent.id, local_id: def.id }
    }
 }
@@ -83,7 +82,7 @@ impl From<ModuleDefId> for ModuleDef {
            ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
            ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
            ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
-            ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
+            ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
            ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
            ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
            ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
@@ -99,7 +98,7 @@ impl From<ModuleDef> for ModuleDefId {
            ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
            ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
            ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
-            ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
+            ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
            ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
            ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
            ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
@@ -147,7 +146,7 @@ impl From<GenericDef> for GenericDefId {
            GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
            GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
            GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
-            GenericDef::EnumVariant(it) => {
+            GenericDef::Variant(it) => {
                GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
            }
            GenericDef::Const(it) => GenericDefId::ConstId(it.id),
@@ -164,7 +163,7 @@ impl From<GenericDefId> for GenericDef {
            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
            GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
            GenericDefId::EnumVariantId(it) => {
-                GenericDef::EnumVariant(EnumVariant { parent: it.parent.into(), id: it.local_id })
+                GenericDef::Variant(Variant { parent: it.parent.into(), id: it.local_id })
            }
            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
        }
@@ -185,7 +184,7 @@ impl From<VariantId> for VariantDef {
    fn from(def: VariantId) -> Self {
        match def {
            VariantId::StructId(it) => VariantDef::Struct(it.into()),
-            VariantId::EnumVariantId(it) => VariantDef::EnumVariant(it.into()),
+            VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
            VariantId::UnionId(it) => VariantDef::Union(it.into()),
        }
    }
@@ -195,7 +194,7 @@ impl From<VariantDef> for VariantId {
    fn from(def: VariantDef) -> Self {
        match def {
            VariantDef::Struct(it) => VariantId::StructId(it.id),
-            VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+            VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
            VariantDef::Union(it) => VariantId::UnionId(it.id),
        }
    }
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index c5b81b252..0dc07c33e 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -10,8 +10,8 @@ use hir_expand::InFile;
 use syntax::ast;
 use crate::{
-    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, Impl, LifetimeParam,
+    db::HirDatabase, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, MacroDef,
-    MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
+    Module, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
 };
 pub trait HasSource {
@@ -73,7 +73,7 @@ impl HasSource for Enum {
        self.id.lookup(db.upcast()).source(db.upcast())
    }
 }
-impl HasSource for EnumVariant {
+impl HasSource for Variant {
    type Ast = ast::Variant;
    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Variant> {
        self.parent.id.child_source(db.upcast()).map(|map| map[self.id].clone())
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 3f4f8d8e4..bdd270c58 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -34,9 +34,9 @@ pub use crate::{
    attrs::{HasAttrs, Namespace},
    code_model::{
        Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
-        Crate, CrateDependency, DefWithBody, Enum, EnumVariant, Field, FieldSource, Function,
+        Crate, CrateDependency, DefWithBody, Enum, Field, FieldSource, Function, GenericDef,
-        GenericDef, HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef,
+        HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef, ScopeDef, Static,
-        ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
+        Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
    },
    has_source::HasSource,
    semantics::{PathResolution, Semantics, SemanticsScope},
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 83ec91f58..25ebf73d8 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -51,7 +51,7 @@ impl PathResolution {
                Some(TypeNs::BuiltinType(*builtin))
            }
            PathResolution::Def(ModuleDef::Const(_))
-            | PathResolution::Def(ModuleDef::EnumVariant(_))
+            | PathResolution::Def(ModuleDef::Variant(_))
            | PathResolution::Def(ModuleDef::Function(_))
            | PathResolution::Def(ModuleDef::Module(_))
            | PathResolution::Def(ModuleDef::Static(_))
@@ -715,7 +715,7 @@ to_def_impls![
    (crate::Function, ast::Fn, fn_to_def),
    (crate::Field, ast::RecordField, record_field_to_def),
    (crate::Field, ast::TupleField, tuple_field_to_def),
-    (crate::EnumVariant, ast::Variant, enum_variant_to_def),
+    (crate::Variant, ast::Variant, enum_variant_to_def),
    (crate::TypeParam, ast::TypeParam, type_param_to_def),
    (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
    (crate::MacroDef, ast::MacroRules, macro_rules_to_def),
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index bf0c959fe..bddc49c05 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -28,8 +28,8 @@ use syntax::{
 };
 use crate::{
-    db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Field, Function, Local,
+    db::HirDatabase, semantics::PathResolution, Adt, Const, Field, Function, Local, MacroDef,
-    MacroDef, ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+    ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Variant,
 };
 use base_db::CrateId;
@@ -230,7 +230,7 @@ impl SourceAnalyzer {
            if let Some(VariantId::EnumVariantId(variant)) =
                self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
            {
-                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+                return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
            }
        }
@@ -242,7 +242,7 @@ impl SourceAnalyzer {
            if let Some(VariantId::EnumVariantId(variant)) =
                self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
            {
-                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+                return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
            }
        }
@@ -251,7 +251,7 @@ impl SourceAnalyzer {
            if let Some(VariantId::EnumVariantId(variant)) =
                self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
            {
-                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+                return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
            }
        }
@@ -260,7 +260,7 @@ impl SourceAnalyzer {
            if let Some(VariantId::EnumVariantId(variant)) =
                self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
            {
-                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+                return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
            }
        }
@@ -459,7 +459,7 @@ pub(crate) fn resolve_hir_path(
            TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
                PathResolution::Def(Adt::from(it).into())
            }
-            TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+            TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
            TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
            TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
            TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
@@ -477,7 +477,7 @@ pub(crate) fn resolve_hir_path(
                ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
                ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
                ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
-                ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                ValueNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
                ValueNs::ImplSelf(impl_id) => PathResolution::SelfType(impl_id.into()),
            };
            Some(res)
@@ -526,7 +526,7 @@ fn resolve_hir_path_qualifier(
        TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
        TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
        TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => PathResolution::Def(Adt::from(it).into()),
-        TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+        TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
        TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
        TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
        TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index eafa3abb6..236d6f1b7 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -3,6 +3,7 @@
 use std::sync::Arc;
 use arena::{map::ArenaMap, Arena};
+use base_db::CrateId;
 use either::Either;
 use hir_expand::{
    name::{AsName, Name},
@@ -66,8 +67,13 @@ pub enum ReprKind {
    Other,
 }
-fn repr_from_value(item_tree: &ItemTree, of: AttrOwner) -> Option<ReprKind> {
+fn repr_from_value(
-    item_tree.attrs(of).by_key("repr").tt_values().find_map(parse_repr_tt)
+    db: &dyn DefDatabase,
+    krate: CrateId,
+    item_tree: &ItemTree,
+    of: AttrOwner,
+) -> Option<ReprKind> {
+    item_tree.attrs(db, krate, of).by_key("repr").tt_values().find_map(parse_repr_tt)
 }
 fn parse_repr_tt(tt: &Subtree) -> Option<ReprKind> {
@@ -86,12 +92,13 @@ fn parse_repr_tt(tt: &Subtree) -> Option<ReprKind> {
 impl StructData {
    pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
        let loc = id.lookup(db);
+        let krate = loc.container.module(db).krate;
        let item_tree = db.item_tree(loc.id.file_id);
-        let repr = repr_from_value(&item_tree, ModItem::from(loc.id.value).into());
+        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
        let strukt = &item_tree[loc.id.value];
-        let variant_data = lower_fields(&item_tree, &cfg_options, &strukt.fields, None);
+        let variant_data = lower_fields(db, krate, &item_tree, &cfg_options, &strukt.fields, None);
        Arc::new(StructData {
            name: strukt.name.clone(),
            variant_data: Arc::new(variant_data),
@@ -100,12 +107,13 @@ impl StructData {
    }
    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
        let loc = id.lookup(db);
+        let krate = loc.container.module(db).krate;
        let item_tree = db.item_tree(loc.id.file_id);
-        let repr = repr_from_value(&item_tree, ModItem::from(loc.id.value).into());
+        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
        let union = &item_tree[loc.id.value];
-        let variant_data = lower_fields(&item_tree, &cfg_options, &union.fields, None);
+        let variant_data = lower_fields(db, krate, &item_tree, &cfg_options, &union.fields, None);
        Arc::new(StructData {
            name: union.name.clone(),
@@ -118,16 +126,23 @@ impl StructData {
 impl EnumData {
    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
        let loc = e.lookup(db);
+        let krate = loc.container.module(db).krate;
        let item_tree = db.item_tree(loc.id.file_id);
-        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
        let enum_ = &item_tree[loc.id.value];
        let mut variants = Arena::new();
        for var_id in enum_.variants.clone() {
-            if item_tree.attrs(var_id.into()).is_cfg_enabled(&cfg_options) {
+            if item_tree.attrs(db, krate, var_id.into()).is_cfg_enabled(&cfg_options) {
                let var = &item_tree[var_id];
-                let var_data =
+                let var_data = lower_fields(
-                    lower_fields(&item_tree, &cfg_options, &var.fields, Some(enum_.visibility));
+                    db,
+                    krate,
+                    &item_tree,
+                    &cfg_options,
+                    &var.fields,
+                    Some(enum_.visibility),
+                );
                variants.alloc(EnumVariantData {
                    name: var.name.clone(),
@@ -170,7 +185,7 @@ fn lower_enum(
        .variant_list()
        .into_iter()
        .flat_map(|it| it.variants())
-        .filter(|var| expander.is_cfg_enabled(var));
+        .filter(|var| expander.is_cfg_enabled(db, var));
    for var in variants {
        trace.alloc(
            || var.clone(),
@@ -262,7 +277,7 @@ fn lower_struct(
    match &ast.value {
        ast::StructKind::Tuple(fl) => {
            for (i, fd) in fl.fields().enumerate() {
-                if !expander.is_cfg_enabled(&fd) {
+                if !expander.is_cfg_enabled(db, &fd) {
                    continue;
                }
@@ -279,7 +294,7 @@ fn lower_struct(
        }
        ast::StructKind::Record(fl) => {
            for fd in fl.fields() {
-                if !expander.is_cfg_enabled(&fd) {
+                if !expander.is_cfg_enabled(db, &fd) {
                    continue;
                }
@@ -299,6 +314,8 @@ fn lower_struct(
 }
 fn lower_fields(
+    db: &dyn DefDatabase,
+    krate: CrateId,
    item_tree: &ItemTree,
    cfg_options: &CfgOptions,
    fields: &Fields,
@@ -308,7 +325,7 @@ fn lower_fields(
        Fields::Record(flds) => {
            let mut arena = Arena::new();
            for field_id in flds.clone() {
-                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                if item_tree.attrs(db, krate, field_id.into()).is_cfg_enabled(cfg_options) {
                    arena.alloc(lower_field(item_tree, &item_tree[field_id], override_visibility));
                }
            }
@@ -317,7 +334,7 @@ fn lower_fields(
        Fields::Tuple(flds) => {
            let mut arena = Arena::new();
            for field_id in flds.clone() {
-                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                if item_tree.attrs(db, krate, field_id.into()).is_cfg_enabled(cfg_options) {
                    arena.alloc(lower_field(item_tree, &item_tree[field_id], override_visibility));
                }
            }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index c64b78445..042e119b1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -2,22 +2,24 @@
 use std::{ops, sync::Arc};
+use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, AstId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
 use itertools::Itertools;
 use mbe::ast_to_token_tree;
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
    match_ast, AstToken, SmolStr, SyntaxNode,
 };
+use test_utils::mark;
 use tt::Subtree;
 use crate::{
    db::DefDatabase,
    item_tree::{ItemTreeId, ItemTreeNode},
    nameres::ModuleSource,
-    path::ModPath,
+    path::{ModPath, PathKind},
    src::HasChildSource,
    AdtId, AttrDefId, Lookup,
 };
@@ -38,12 +40,16 @@ impl From<Documentation> for String {
    }
 }
+/// Syntactical attributes, without filtering of `cfg_attr`s.
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct Attrs {
+pub(crate) struct RawAttrs {
    entries: Option<Arc<[Attr]>>,
 }
-impl ops::Deref for Attrs {
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct Attrs(RawAttrs);
+impl ops::Deref for RawAttrs {
    type Target = [Attr];
    fn deref(&self) -> &[Attr] {
@@ -54,19 +60,147 @@ impl ops::Deref for Attrs {
    }
 }
+impl ops::Deref for Attrs {
+    type Target = [Attr];
+    fn deref(&self) -> &[Attr] {
+        match &self.0.entries {
+            Some(it) => &*it,
+            None => &[],
+        }
+    }
+}
+impl RawAttrs {
+    pub(crate) const EMPTY: Self = Self { entries: None };
+    pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Self {
+        let attrs: Vec<_> = collect_attrs(owner).collect();
+        let entries = if attrs.is_empty() {
+            // Avoid heap allocation
+            None
+        } else {
+            Some(
+                attrs
+                    .into_iter()
+                    .enumerate()
+                    .flat_map(|(i, attr)| match attr {
+                        Either::Left(attr) => Attr::from_src(attr, hygiene).map(|attr| (i, attr)),
+                        Either::Right(comment) => comment.doc_comment().map(|doc| {
+                            (
+                                i,
+                                Attr {
+                                    index: 0,
+                                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                                    path: ModPath::from(hir_expand::name!(doc)),
+                                },
+                            )
+                        }),
+                    })
+                    .map(|(i, attr)| Attr { index: i as u32, ..attr })
+                    .collect(),
+            )
+        };
+        Self { entries }
+    }
+    fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Self {
+        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
+        Self::new(owner.value, &hygiene)
+    }
+    pub(crate) fn merge(&self, other: Self) -> Self {
+        match (&self.entries, &other.entries) {
+            (None, None) => Self::EMPTY,
+            (Some(entries), None) | (None, Some(entries)) => {
+                Self { entries: Some(entries.clone()) }
+            }
+            (Some(a), Some(b)) => {
+                Self { entries: Some(a.iter().chain(b.iter()).cloned().collect()) }
+            }
+        }
+    }
+    /// Processes `cfg_attr`s, returning the resulting semantic `Attrs`.
+    pub(crate) fn filter(self, db: &dyn DefDatabase, krate: CrateId) -> Attrs {
+        let has_cfg_attrs = self.iter().any(|attr| {
+            attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr])
+        });
+        if !has_cfg_attrs {
+            return Attrs(self);
+        }
+        let crate_graph = db.crate_graph();
+        let new_attrs = self
+            .iter()
+            .filter_map(|attr| {
+                let attr = attr.clone();
+                let is_cfg_attr =
+                    attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr]);
+                if !is_cfg_attr {
+                    return Some(attr);
+                }
+                let subtree = match &attr.input {
+                    Some(AttrInput::TokenTree(it)) => it,
+                    _ => return Some(attr),
+                };
+                // Input subtree is: `(cfg, attr)`
+                // Split it up into a `cfg` and an `attr` subtree.
+                // FIXME: There should be a common API for this.
+                let mut saw_comma = false;
+                let (mut cfg, attr): (Vec<_>, Vec<_>) =
+                    subtree.clone().token_trees.into_iter().partition(|tree| {
+                        if saw_comma {
+                            return false;
+                        }
+                        match tree {
+                            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
+                                saw_comma = true;
+                            }
+                            _ => {}
+                        }
+                        true
+                    });
+                cfg.pop(); // `,` ends up in here
+                let attr = Subtree { delimiter: None, token_trees: attr };
+                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg };
+                let cfg = CfgExpr::parse(&cfg);
+                let cfg_options = &crate_graph[krate].cfg_options;
+                if cfg_options.check(&cfg) == Some(false) {
+                    None
+                } else {
+                    mark::hit!(cfg_attr_active);
+                    let attr = ast::Attr::parse(&format!("#[{}]", attr)).ok()?;
+                    let hygiene = Hygiene::new_unhygienic(); // FIXME
+                    Attr::from_src(attr, &hygiene)
+                }
+            })
+            .collect();
+        Attrs(RawAttrs { entries: Some(new_attrs) })
+    }
+}
 impl Attrs {
-    pub const EMPTY: Attrs = Attrs { entries: None };
+    pub const EMPTY: Self = Self(RawAttrs::EMPTY);
    pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
-        match def {
+        let raw_attrs = match def {
            AttrDefId::ModuleId(module) => {
                let def_map = db.crate_def_map(module.krate);
                let mod_data = &def_map[module.local_id];
                match mod_data.declaration_source(db) {
                    Some(it) => {
-                        Attrs::from_attrs_owner(db, it.as_ref().map(|it| it as &dyn AttrsOwner))
+                        RawAttrs::from_attrs_owner(db, it.as_ref().map(|it| it as &dyn AttrsOwner))
                    }
-                    None => Attrs::from_attrs_owner(
+                    None => RawAttrs::from_attrs_owner(
                        db,
                        mod_data.definition_source(db).as_ref().map(|src| match src {
                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
@@ -78,14 +212,14 @@ impl Attrs {
            AttrDefId::FieldId(it) => {
                let src = it.parent.child_source(db);
                match &src.value[it.local_id] {
-                    Either::Left(_tuple) => Attrs::default(),
+                    Either::Left(_tuple) => RawAttrs::default(),
-                    Either::Right(record) => Attrs::from_attrs_owner(db, src.with_value(record)),
+                    Either::Right(record) => RawAttrs::from_attrs_owner(db, src.with_value(record)),
                }
            }
            AttrDefId::EnumVariantId(var_id) => {
                let src = var_id.parent.child_source(db);
                let src = src.as_ref().map(|it| &it[var_id.local_id]);
-                Attrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
+                RawAttrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
            }
            AttrDefId::AdtId(it) => match it {
                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
@@ -101,55 +235,9 @@ impl Attrs {
            AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
            AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
            AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-        }
-    }
-    pub fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Attrs {
-        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
-        Attrs::new(owner.value, &hygiene)
-    }
-    pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Attrs {
-        let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
-            .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
-        let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
-        let attrs = outer_attrs
-            .chain(inner_attrs.into_iter().flatten())
-            .map(|attr| (attr.syntax().text_range().start(), Attr::from_src(attr, hygiene)));
-        let outer_docs =
-            ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
-        let docs = outer_docs.chain(inner_docs.into_iter().flatten()).map(|docs_text| {
-            (
-                docs_text.syntax().text_range().start(),
-                docs_text.doc_comment().map(|doc| Attr {
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                    path: ModPath::from(hir_expand::name!(doc)),
-                }),
-            )
-        });
-        // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-        let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
-        let entries = if attrs.is_empty() {
-            // Avoid heap allocation
-            None
-        } else {
-            Some(attrs.into_iter().flat_map(|(_, attr)| attr).collect())
        };
-        Attrs { entries }
-    }
-    pub fn merge(&self, other: Attrs) -> Attrs {
+        raw_attrs.filter(db, def.krate(db))
-        match (&self.entries, &other.entries) {
-            (None, None) => Attrs { entries: None },
-            (Some(entries), None) | (None, Some(entries)) => {
-                Attrs { entries: Some(entries.clone()) }
-            }
-            (Some(a), Some(b)) => {
-                Attrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) }
-            }
-        }
    }
    pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
@@ -157,7 +245,6 @@ impl Attrs {
    }
    pub fn cfg(&self) -> Option<CfgExpr> {
-        // FIXME: handle cfg_attr :-)
        let mut cfgs = self.by_key("cfg").tt_values().map(CfgExpr::parse).collect::<Vec<_>>();
        match cfgs.len() {
            0 => None,
@@ -228,6 +315,7 @@ fn inner_attributes(
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
+    index: u32,
    pub(crate) path: ModPath,
    pub(crate) input: Option<AttrInput>,
 }
@@ -254,7 +342,59 @@ impl Attr {
        } else {
            None
        };
-        Some(Attr { path, input })
+        Some(Attr { index: 0, path, input })
+    }
+    /// Maps this lowered `Attr` back to its original syntax node.
+    ///
+    /// `owner` must be the original owner of the attribute.
+    ///
+    /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of
+    /// the attribute represented by `Attr`.
+    pub fn to_src(&self, owner: &dyn AttrsOwner) -> Either<ast::Attr, ast::Comment> {
+        collect_attrs(owner).nth(self.index as usize).unwrap_or_else(|| {
+            panic!("cannot find `Attr` at index {} in {}", self.index, owner.syntax())
+        })
+    }
+    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
+    /// to derive macros.
+    ///
+    /// Returns `None` when the attribute is not a well-formed `#[derive]` attribute.
+    pub(crate) fn parse_derive(&self) -> Option<impl Iterator<Item = ModPath>> {
+        if self.path.as_ident() != Some(&hir_expand::name![derive]) {
+            return None;
+        }
+        match &self.input {
+            Some(AttrInput::TokenTree(args)) => {
+                let mut counter = 0;
+                let paths = args
+                    .token_trees
+                    .iter()
+                    .group_by(move |tt| {
+                        match tt {
+                            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
+                                counter += 1;
+                            }
+                            _ => {}
+                        }
+                        counter
+                    })
+                    .into_iter()
+                    .map(|(_, tts)| {
+                        let segments = tts.filter_map(|tt| match tt {
+                            tt::TokenTree::Leaf(tt::Leaf::Ident(id)) => Some(id.as_name()),
+                            _ => None,
+                        });
+                        ModPath::from_segments(PathKind::Plain, segments)
+                    })
+                    .collect::<Vec<_>>();
+                Some(paths.into_iter())
+            }
+            _ => None,
+        }
    }
 }
@@ -283,7 +423,7 @@ impl<'a> AttrQuery<'a> {
        self.attrs().next().is_some()
    }
-    fn attrs(self) -> impl Iterator<Item = &'a Attr> {
+    pub(crate) fn attrs(self) -> impl Iterator<Item = &'a Attr> {
        let key = self.key;
        self.attrs
            .iter()
@@ -291,16 +431,36 @@ impl<'a> AttrQuery<'a> {
    }
 }
-fn attrs_from_ast<N>(src: AstId<N>, db: &dyn DefDatabase) -> Attrs
+fn attrs_from_ast<N>(src: AstId<N>, db: &dyn DefDatabase) -> RawAttrs
 where
    N: ast::AttrsOwner,
 {
    let src = InFile::new(src.file_id, src.to_node(db.upcast()));
-    Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+    RawAttrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
 }
-fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> Attrs {
+fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> RawAttrs {
    let tree = db.item_tree(id.file_id);
    let mod_item = N::id_to_mod_item(id.value);
-    tree.attrs(mod_item.into()).clone()
+    tree.raw_attrs(mod_item.into()).clone()
+}
+fn collect_attrs(owner: &dyn AttrsOwner) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
+    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
+        .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
+    let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
+    let attrs = outer_attrs
+        .chain(inner_attrs.into_iter().flatten())
+        .map(|attr| (attr.syntax().text_range().start(), Either::Left(attr)));
+    let outer_docs =
+        ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
+    let docs = outer_docs
+        .chain(inner_docs.into_iter().flatten())
+        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
+    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
+    let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+    attrs.into_iter().map(|(_, attr)| attr)
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index c5d6f5fb0..998b82601 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -24,7 +24,7 @@ use test_utils::mark;
 pub(crate) use lower::LowerCtx;
 use crate::{
-    attr::Attrs,
+    attr::{Attrs, RawAttrs},
    db::DefDatabase,
    expr::{Expr, ExprId, Pat, PatId},
    item_scope::BuiltinShadowMode,
@@ -40,6 +40,7 @@ use crate::{
 pub(crate) struct CfgExpander {
    cfg_options: CfgOptions,
    hygiene: Hygiene,
+    krate: CrateId,
 }
 pub(crate) struct Expander {
@@ -65,15 +66,15 @@ impl CfgExpander {
    ) -> CfgExpander {
        let hygiene = Hygiene::new(db.upcast(), current_file_id);
        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
-        CfgExpander { cfg_options, hygiene }
+        CfgExpander { cfg_options, hygiene, krate }
    }
-    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+    pub(crate) fn parse_attrs(&self, db: &dyn DefDatabase, owner: &dyn ast::AttrsOwner) -> Attrs {
-        Attrs::new(owner, &self.hygiene)
+        RawAttrs::new(owner, &self.hygiene).filter(db, self.krate)
    }
-    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+    pub(crate) fn is_cfg_enabled(&self, db: &dyn DefDatabase, owner: &dyn ast::AttrsOwner) -> bool {
-        let attrs = self.parse_attrs(owner);
+        let attrs = self.parse_attrs(db, owner);
        attrs.is_cfg_enabled(&self.cfg_options)
    }
 }
@@ -189,8 +190,8 @@ impl Expander {
        InFile { file_id: self.current_file_id, value }
    }
-    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+    pub(crate) fn parse_attrs(&self, db: &dyn DefDatabase, owner: &dyn ast::AttrsOwner) -> Attrs {
-        self.cfg_expander.parse_attrs(owner)
+        self.cfg_expander.parse_attrs(db, owner)
    }
    pub(crate) fn cfg_options(&self) -> &CfgOptions {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 3b3d74987..0f404be1b 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -963,7 +963,7 @@ impl ExprCollector<'_> {
    /// Returns `None` (and emits diagnostics) when `owner` if `#[cfg]`d out, and `Some(())` when
    /// not.
    fn check_cfg(&mut self, owner: &dyn ast::AttrsOwner) -> Option<()> {
-        match self.expander.parse_attrs(owner).cfg() {
+        match self.expander.parse_attrs(self.db, owner).cfg() {
            Some(cfg) => {
                if self.expander.cfg_options().check(&cfg) != Some(false) {
                    return Some(());
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index dd3a906af..e7b7724f7 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -35,6 +35,7 @@ pub struct FunctionData {
 impl FunctionData {
    pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
        let loc = func.lookup(db);
+        let krate = loc.container.module(db).krate;
        let item_tree = db.item_tree(loc.id.file_id);
        let func = &item_tree[loc.id.value];
@@ -42,7 +43,7 @@ impl FunctionData {
            name: func.name.clone(),
            params: func.params.to_vec(),
            ret_type: func.ret_type.clone(),
-            attrs: item_tree.attrs(ModItem::from(loc.id.value).into()).clone(),
+            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()).clone(),
            has_self_param: func.has_self_param,
            has_body: func.has_body,
            is_unsafe: func.is_unsafe,
@@ -233,7 +234,7 @@ fn collect_items(
        match item {
            AssocItem::Function(id) => {
                let item = &item_tree[id];
-                let attrs = item_tree.attrs(ModItem::from(id).into());
+                let attrs = item_tree.attrs(db, module.krate, ModItem::from(id).into());
                if !attrs.is_cfg_enabled(&cfg_options) {
                    continue;
                }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index b8e09e3af..100dbf5d6 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -12,7 +12,8 @@ use std::{
 };
 use arena::{Arena, Idx, RawId};
-use ast::{AstNode, AttrsOwner, NameOwner, StructKind};
+use ast::{AstNode, NameOwner, StructKind};
+use base_db::CrateId;
 use either::Either;
 use hir_expand::{
    ast_id_map::FileAstId,
@@ -26,7 +27,7 @@ use syntax::{ast, match_ast};
 use test_utils::mark;
 use crate::{
-    attr::Attrs,
+    attr::{Attrs, RawAttrs},
    db::DefDatabase,
    generics::GenericParams,
    path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
@@ -67,7 +68,7 @@ impl GenericParamsId {
 #[derive(Debug, Eq, PartialEq)]
 pub struct ItemTree {
    top_level: SmallVec<[ModItem; 1]>,
-    attrs: FxHashMap<AttrOwner, Attrs>,
+    attrs: FxHashMap<AttrOwner, RawAttrs>,
    inner_items: FxHashMap<FileAstId<ast::Item>, SmallVec<[ModItem; 1]>>,
    data: Option<Box<ItemTreeData>>,
@@ -88,7 +89,7 @@ impl ItemTree {
        let mut item_tree = match_ast! {
            match syntax {
                ast::SourceFile(file) => {
-                    top_attrs = Some(Attrs::new(&file, &hygiene));
+                    top_attrs = Some(RawAttrs::new(&file, &hygiene));
                    ctx.lower_module_items(&file)
                },
                ast::MacroItems(items) => {
@@ -180,12 +181,16 @@ impl ItemTree {
    }
    /// Returns the inner attributes of the source file.
-    pub fn top_level_attrs(&self) -> &Attrs {
+    pub fn top_level_attrs(&self, db: &dyn DefDatabase, krate: CrateId) -> Attrs {
-        self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&Attrs::EMPTY)
+        self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&RawAttrs::EMPTY).clone().filter(db, krate)
    }
-    pub fn attrs(&self, of: AttrOwner) -> &Attrs {
+    pub(crate) fn raw_attrs(&self, of: AttrOwner) -> &RawAttrs {
-        self.attrs.get(&of).unwrap_or(&Attrs::EMPTY)
+        self.attrs.get(&of).unwrap_or(&RawAttrs::EMPTY)
+    }
+    pub fn attrs(&self, db: &dyn DefDatabase, krate: CrateId, of: AttrOwner) -> Attrs {
+        self.raw_attrs(of).clone().filter(db, krate)
    }
    /// Returns the lowered inner items that `ast` corresponds to.
@@ -490,7 +495,6 @@ pub struct Import {
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
    pub is_glob: bool,
-    pub is_prelude: bool,
    /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
    /// `Import`s can map to the same `use` item.
    pub ast_id: FileAstId<ast::Use>,
@@ -506,8 +510,6 @@ pub struct ExternCrate {
    pub name: Name,
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
-    /// Whether this is a `#[macro_use] extern crate ...`.
-    pub is_macro_use: bool,
    pub ast_id: FileAstId<ast::ExternCrate>,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 7de385ee8..3b206ef85 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -10,7 +10,6 @@ use syntax::{
 };
 use crate::{
-    attr::Attrs,
    generics::{GenericParams, TypeParamData, TypeParamProvenance},
    type_ref::LifetimeRef,
 };
@@ -105,7 +104,7 @@ impl Ctx {
            | ast::Item::MacroDef(_) => {}
        };
-        let attrs = Attrs::new(item, &self.hygiene);
+        let attrs = RawAttrs::new(item, &self.hygiene);
        let items = match item {
            ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into),
            ast::Item::Union(ast) => self.lower_union(ast).map(Into::into),
@@ -138,7 +137,7 @@ impl Ctx {
        items
    }
-    fn add_attrs(&mut self, item: AttrOwner, attrs: Attrs) {
+    fn add_attrs(&mut self, item: AttrOwner, attrs: RawAttrs) {
        match self.tree.attrs.entry(item) {
            Entry::Occupied(mut entry) => {
                *entry.get_mut() = entry.get().merge(attrs);
@@ -205,7 +204,7 @@ impl Ctx {
        for field in fields.fields() {
            if let Some(data) = self.lower_record_field(&field) {
                let idx = self.data().fields.alloc(data);
-                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(&field, &self.hygiene));
            }
        }
        let end = self.next_field_idx();
@@ -225,7 +224,7 @@ impl Ctx {
        for (i, field) in fields.fields().enumerate() {
            let data = self.lower_tuple_field(i, &field);
            let idx = self.data().fields.alloc(data);
-            self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+            self.add_attrs(idx.into(), RawAttrs::new(&field, &self.hygiene));
        }
        let end = self.next_field_idx();
        IdRange::new(start..end)
@@ -270,7 +269,7 @@ impl Ctx {
        for variant in variants.variants() {
            if let Some(data) = self.lower_variant(&variant) {
                let idx = self.data().variants.alloc(data);
-                self.add_attrs(idx.into(), Attrs::new(&variant, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(&variant, &self.hygiene));
            }
        }
        let end = self.next_variant_idx();
@@ -438,7 +437,7 @@ impl Ctx {
            self.with_inherited_visibility(visibility, |this| {
                list.assoc_items()
                    .filter_map(|item| {
-                        let attrs = Attrs::new(&item, &this.hygiene);
+                        let attrs = RawAttrs::new(&item, &this.hygiene);
                        this.collect_inner_items(item.syntax());
                        this.lower_assoc_item(&item).map(|item| {
                            this.add_attrs(ModItem::from(item).into(), attrs);
@@ -475,7 +474,7 @@ impl Ctx {
            .filter_map(|item| {
                self.collect_inner_items(item.syntax());
                let assoc = self.lower_assoc_item(&item)?;
-                let attrs = Attrs::new(&item, &self.hygiene);
+                let attrs = RawAttrs::new(&item, &self.hygiene);
                self.add_attrs(ModItem::from(assoc).into(), attrs);
                Some(assoc)
            })
@@ -486,8 +485,6 @@ impl Ctx {
    }
    fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> {
-        // FIXME: cfg_attr
-        let is_prelude = use_item.has_atom_attr("prelude_import");
        let visibility = self.lower_visibility(use_item);
        let ast_id = self.source_ast_id_map.ast_id(use_item);
@@ -503,7 +500,6 @@ impl Ctx {
                    alias,
                    visibility,
                    is_glob,
-                    is_prelude,
                    ast_id,
                    index: imports.len(),
                })));
@@ -523,10 +519,8 @@ impl Ctx {
        });
        let visibility = self.lower_visibility(extern_crate);
        let ast_id = self.source_ast_id_map.ast_id(extern_crate);
-        // FIXME: cfg_attr
-        let is_macro_use = extern_crate.has_atom_attr("macro_use");
-        let res = ExternCrate { name, alias, visibility, is_macro_use, ast_id };
+        let res = ExternCrate { name, alias, visibility, ast_id };
        Some(id(self.data().extern_crates.alloc(res)))
    }
@@ -560,7 +554,7 @@ impl Ctx {
            list.extern_items()
                .filter_map(|item| {
                    self.collect_inner_items(item.syntax());
-                    let attrs = Attrs::new(&item, &self.hygiene);
+                    let attrs = RawAttrs::new(&item, &self.hygiene);
                    let id: ModItem = match item {
                        ast::ExternItem::Fn(ast) => {
                            let func_id = self.lower_function(&ast)?;
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 7e2199a9c..ba09a9126 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -425,6 +425,16 @@ impl HasModule for AdtId {
    }
 }
+impl HasModule for VariantId {
+    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
+        match self {
+            VariantId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
+            VariantId::StructId(it) => it.lookup(db).container.module(db),
+            VariantId::UnionId(it) => it.lookup(db).container.module(db),
+        }
+    }
+}
 impl HasModule for DefWithBodyId {
    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
        match self {
@@ -465,6 +475,26 @@ impl HasModule for StaticLoc {
    }
 }
+impl AttrDefId {
+    pub fn krate(&self, db: &dyn db::DefDatabase) -> CrateId {
+        match self {
+            AttrDefId::ModuleId(it) => it.krate,
+            AttrDefId::FieldId(it) => it.parent.module(db).krate,
+            AttrDefId::AdtId(it) => it.module(db).krate,
+            AttrDefId::FunctionId(it) => it.lookup(db).module(db).krate,
+            AttrDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db).krate,
+            AttrDefId::StaticId(it) => it.lookup(db).module(db).krate,
+            AttrDefId::ConstId(it) => it.lookup(db).module(db).krate,
+            AttrDefId::TraitId(it) => it.lookup(db).container.module(db).krate,
+            AttrDefId::TypeAliasId(it) => it.lookup(db).module(db).krate,
+            AttrDefId::ImplId(it) => it.lookup(db).container.module(db).krate,
+            // FIXME: `MacroDefId` should store the defining module, then this can implement
+            // `HasModule`
+            AttrDefId::MacroDefId(it) => it.krate,
+        }
+    }
+}
 /// A helper trait for converting to MacroCallId
 pub trait AsMacroCall {