107 files changed, 1579 insertions, 831 deletions
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 114974465..960af5ab3 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -53,7 +53,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
            if let Some(type_params) = type_params {
                let lifetime_params = type_params
                    .lifetime_params()
-                    .filter_map(|it| it.lifetime_token())
+                    .filter_map(|it| it.lifetime())
                    .map(|it| it.text().clone());
                let type_params = type_params
                    .type_params()
diff --git a/crates/assists/src/handlers/generate_new.rs b/crates/assists/src/handlers/generate_new.rs
index 7db10f276..c5fec4e0a 100644
--- a/crates/assists/src/handlers/generate_new.rs
+++ b/crates/assists/src/handlers/generate_new.rs
@@ -99,7 +99,7 @@ fn generate_impl_text(strukt: &ast::Struct, code: &str) -> String {
    if let Some(type_params) = type_params {
        let lifetime_params = type_params
            .lifetime_params()
-            .filter_map(|it| it.lifetime_token())
+            .filter_map(|it| it.lifetime())
            .map(|it| it.text().clone());
        let type_params =
            type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
diff --git a/crates/assists/src/handlers/introduce_named_lifetime.rs b/crates/assists/src/handlers/introduce_named_lifetime.rs
index 4cc8dae65..ab8fe3ea9 100644
--- a/crates/assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/assists/src/handlers/introduce_named_lifetime.rs
@@ -1,7 +1,7 @@
 use rustc_hash::FxHashSet;
 use syntax::{
    ast::{self, GenericParamsOwner, NameOwner},
-    AstNode, SyntaxKind, TextRange, TextSize,
+    AstNode, TextRange, TextSize,
 };
 use crate::{assist_context::AssistBuilder, AssistContext, AssistId, AssistKind, Assists};
@@ -35,13 +35,12 @@ static ASSIST_LABEL: &str = "Introduce named lifetime";
 // FIXME: How can we handle renaming any one of multiple anonymous lifetimes?
 // FIXME: should also add support for the case fun(f: &Foo) -> &<|>Foo
 pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let lifetime_token = ctx
+    let lifetime =
-        .find_token_syntax_at_offset(SyntaxKind::LIFETIME)
+        ctx.find_node_at_offset::<ast::Lifetime>().filter(|lifetime| lifetime.text() == "'_")?;
-        .filter(|lifetime| lifetime.text() == "'_")?;
+    if let Some(fn_def) = lifetime.syntax().ancestors().find_map(ast::Fn::cast) {
-    if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::Fn::cast) {
+        generate_fn_def_assist(acc, &fn_def, lifetime.lifetime_ident_token()?.text_range())
-        generate_fn_def_assist(acc, &fn_def, lifetime_token.text_range())
+    } else if let Some(impl_def) = lifetime.syntax().ancestors().find_map(ast::Impl::cast) {
-    } else if let Some(impl_def) = lifetime_token.ancestors().find_map(ast::Impl::cast) {
+        generate_impl_def_assist(acc, &impl_def, lifetime.lifetime_ident_token()?.text_range())
-        generate_impl_def_assist(acc, &impl_def, lifetime_token.text_range())
    } else {
        None
    }
@@ -58,7 +57,7 @@ fn generate_fn_def_assist(
    let end_of_fn_ident = fn_def.name()?.ident_token()?.text_range().end();
    let self_param =
        // use the self if it's a reference and has no explicit lifetime
-        param_list.self_param().filter(|p| p.lifetime_token().is_none() && p.amp_token().is_some());
+        param_list.self_param().filter(|p| p.lifetime().is_none() && p.amp_token().is_some());
    // compute the location which implicitly has the same lifetime as the anonymous lifetime
    let loc_needing_lifetime = if let Some(self_param) = self_param {
        // if we have a self reference, use that
@@ -68,9 +67,7 @@ fn generate_fn_def_assist(
        let fn_params_without_lifetime: Vec<_> = param_list
            .params()
            .filter_map(|param| match param.ty() {
-                Some(ast::Type::RefType(ascribed_type))
+                Some(ast::Type::RefType(ascribed_type)) if ascribed_type.lifetime().is_none() => {
-                    if ascribed_type.lifetime_token() == None =>
-                {
                    Some(ascribed_type.amp_token()?.text_range().end())
                }
                _ => None,
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index b9315f6c0..93869f92e 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -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,15 +144,24 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
        })
    })
    .filter(|(mod_path, _)| mod_path.len() > 1)
-    .filter_map(|(import_path, definition)| {
+    .collect::<Vec<_>>();
+    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
+        if let Some(name) = mod_path.segments.last().map(|name| name.to_string().to_lowercase()) {
+            if name.contains(&potential_import_name.to_lowercase()) {
+                return 0;
+            }
+        }
+        1
+    });
+    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(())
 }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7ffa79996..3248f6d20 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -267,7 +267,12 @@ impl ModuleDef {
            _ => return,
        };
-        hir_ty::diagnostics::validate_module_item(db, id, sink)
+        let module = match self.module(db) {
+            Some(it) => it,
+            None => return,
+        };
+        hir_ty::diagnostics::validate_module_item(db, module.id.krate, id, sink)
    }
 }
@@ -397,9 +402,9 @@ impl Module {
        def_map[self.id.local_id].scope.declarations().map(ModuleDef::from).collect()
    }
-    pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<ImplDef> {
+    pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {
        let def_map = db.crate_def_map(self.id.krate);
-        def_map[self.id.local_id].scope.impls().map(ImplDef::from).collect()
+        def_map[self.id.local_id].scope.impls().map(Impl::from).collect()
    }
    pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module {
@@ -780,8 +785,9 @@ impl Function {
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+        let krate = self.module(db).id.krate;
        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
-        hir_ty::diagnostics::validate_module_item(db, self.id.into(), sink);
+        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
    }
@@ -970,7 +976,7 @@ impl MacroDef {
    /// defines this macro. The reasons for this is that macros are expanded
    /// early, in `hir_expand`, where modules simply do not exist yet.
    pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
-        let krate = self.id.krate?;
+        let krate = self.id.krate;
        let module_id = db.crate_def_map(krate).root;
        Some(Module::new(Crate { id: krate }, module_id))
    }
@@ -1007,7 +1013,7 @@ pub enum AssocItem {
 }
 pub enum AssocItemContainer {
    Trait(Trait),
-    ImplDef(ImplDef),
+    Impl(Impl),
 }
 pub trait AsAssocItem {
    fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem>;
@@ -1064,7 +1070,7 @@ impl AssocItem {
        };
        match container {
            AssocContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),
-            AssocContainerId::ImplId(id) => AssocItemContainer::ImplDef(id.into()),
+            AssocContainerId::ImplId(id) => AssocItemContainer::Impl(id.into()),
            AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
        }
    }
@@ -1086,7 +1092,7 @@ pub enum GenericDef {
    Adt(Adt),
    Trait(Trait),
    TypeAlias(TypeAlias),
-    ImplDef(ImplDef),
+    Impl(Impl),
    // enum variants cannot have generics themselves, but their parent enums
    // can, and this makes some code easier to write
    EnumVariant(EnumVariant),
@@ -1098,7 +1104,7 @@ impl_from!(
    Adt(Struct, Enum, Union),
    Trait,
    TypeAlias,
-    ImplDef,
+    Impl,
    EnumVariant,
    Const
    for GenericDef
@@ -1268,30 +1274,28 @@ impl LifetimeParam {
 // FIXME: rename from `ImplDef` to `Impl`
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImplDef {
+pub struct Impl {
    pub(crate) id: ImplId,
 }
-impl ImplDef {
+impl Impl {
-    pub fn all_in_crate(db: &dyn HirDatabase, krate: Crate) -> Vec<ImplDef> {
+    pub fn all_in_crate(db: &dyn HirDatabase, krate: Crate) -> Vec<Impl> {
        let inherent = db.inherent_impls_in_crate(krate.id);
        let trait_ = db.trait_impls_in_crate(krate.id);
        inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
    }
-    pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplDef> {
+    pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec<Impl> {
        let impls = db.trait_impls_in_crate(krate.id);
        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());
@@ -1325,6 +1329,7 @@ impl ImplDef {
        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()
@@ -1904,7 +1909,7 @@ pub enum ScopeDef {
    ModuleDef(ModuleDef),
    MacroDef(MacroDef),
    GenericParam(TypeParam),
-    ImplSelfType(ImplDef),
+    ImplSelfType(Impl),
    AdtSelfType(Adt),
    Local(Local),
    Unknown,
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index 8d949b264..d01e1b33d 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -6,8 +6,8 @@ pub use hir_def::db::{
    FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery, InternConstQuery,
    InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
    InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery, InternUnionQuery,
-    ItemTreeQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery, StructDataQuery,
+    ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
-    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
+    TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index dd3fcfe4a..8d0f84508 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -39,7 +39,7 @@ from_id![
    (hir_def::StaticId, crate::Static),
    (hir_def::ConstId, crate::Const),
    (hir_def::FunctionId, crate::Function),
-    (hir_def::ImplId, crate::ImplDef),
+    (hir_def::ImplId, crate::Impl),
    (hir_def::TypeParamId, crate::TypeParam),
    (hir_def::LifetimeParamId, crate::LifetimeParam),
    (hir_expand::MacroDefId, crate::MacroDef)
@@ -146,7 +146,7 @@ impl From<GenericDef> for GenericDefId {
            GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
            GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
            GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
-            GenericDef::ImplDef(it) => GenericDefId::ImplId(it.id),
+            GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
            GenericDef::EnumVariant(it) => {
                GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
            }
@@ -162,7 +162,7 @@ impl From<GenericDefId> for GenericDef {
            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
-            GenericDefId::ImplId(it) => GenericDef::ImplDef(it.into()),
+            GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
            GenericDefId::EnumVariantId(it) => {
                GenericDef::EnumVariant(EnumVariant { parent: it.parent.into(), id: it.local_id })
            }
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 04845037f..c5b81b252 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, ImplDef,
+    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, Impl, LifetimeParam,
-    LifetimeParam, MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
+    MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
 };
 pub trait HasSource {
@@ -110,15 +110,15 @@ impl HasSource for TypeAlias {
    }
 }
 impl HasSource for MacroDef {
-    type Ast = ast::MacroRules;
+    type Ast = ast::Macro;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::MacroRules> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Macro> {
        InFile {
            file_id: self.id.ast_id.expect("MacroDef without ast_id").file_id,
            value: self.id.ast_id.expect("MacroDef without ast_id").to_node(db.upcast()),
        }
    }
 }
-impl HasSource for ImplDef {
+impl HasSource for Impl {
    type Ast = ast::Impl;
    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Impl> {
        self.id.lookup(db.upcast()).source(db.upcast())
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 0f399a2c6..3f4f8d8e4 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -35,7 +35,7 @@ pub use crate::{
    code_model::{
        Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
        Crate, CrateDependency, DefWithBody, Enum, EnumVariant, Field, FieldSource, Function,
-        GenericDef, HasVisibility, ImplDef, LifetimeParam, Local, MacroDef, Module, ModuleDef,
+        GenericDef, HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef,
        ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
    },
    has_source::HasSource,
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 5959ac4ca..83ec91f58 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -25,7 +25,7 @@ use crate::{
    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, SourceAnalyzer},
-    AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, LifetimeParam, Local,
+    AssocItem, Callable, Crate, Field, Function, HirFileId, Impl, InFile, LifetimeParam, Local,
    MacroDef, Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
    VariantDef,
 };
@@ -38,7 +38,7 @@ pub enum PathResolution {
    Local(Local),
    /// A generic parameter
    TypeParam(TypeParam),
-    SelfType(ImplDef),
+    SelfType(Impl),
    Macro(MacroDef),
    AssocItem(AssocItem),
 }
@@ -178,9 +178,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
    }
-    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    pub fn resolve_lifetime_param(&self, lifetime: &ast::Lifetime) -> Option<LifetimeParam> {
-    pub fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        self.imp.resolve_lifetime_param(lifetime)
-        self.imp.resolve_lifetime_param(lifetime_token)
    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
@@ -402,13 +401,9 @@ impl<'db> SemanticsImpl<'db> {
            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
    }
-    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    fn resolve_lifetime_param(&self, lifetime: &ast::Lifetime) -> Option<LifetimeParam> {
-    fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        let text = lifetime.text();
-        if lifetime_token.kind() != syntax::SyntaxKind::LIFETIME {
+        let lifetime_param = lifetime.syntax().ancestors().find_map(|syn| {
-            return None;
-        }
-        let lifetime_text = lifetime_token.text();
-        let lifetime_param = lifetime_token.parent().ancestors().find_map(|syn| {
            let gpl = match_ast! {
                match syn {
                    ast::Fn(it) => it.generic_param_list()?,
@@ -424,7 +419,7 @@ impl<'db> SemanticsImpl<'db> {
                }
            };
            gpl.lifetime_params()
-                .find(|tp| tp.lifetime_token().as_ref().map(|lt| lt.text()) == Some(lifetime_text))
+                .find(|tp| tp.lifetime().as_ref().map(|lt| lt.text()) == Some(text))
        })?;
        let src = self.find_file(lifetime_param.syntax().clone()).with_value(lifetime_param);
        ToDef::to_def(self, src)
@@ -713,7 +708,7 @@ to_def_impls![
    (crate::Enum, ast::Enum, enum_to_def),
    (crate::Union, ast::Union, union_to_def),
    (crate::Trait, ast::Trait, trait_to_def),
-    (crate::ImplDef, ast::Impl, impl_to_def),
+    (crate::Impl, ast::Impl, impl_to_def),
    (crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
    (crate::Const, ast::Const, const_to_def),
    (crate::Static, ast::Static, static_to_def),
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index a333d7aea..3efca5baa 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -157,8 +157,8 @@ impl SourceToDefCtx<'_, '_> {
        let file_id = src.file_id.original_file(self.db.upcast());
        let krate = self.file_to_def(file_id)?.krate;
        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
-        let ast_id = Some(AstId::new(src.file_id, file_ast_id));
+        let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast()));
-        Some(MacroDefId { krate: Some(krate), ast_id, kind, local_inner: false })
+        Some(MacroDefId { krate, ast_id, kind, local_inner: false })
    }
    pub(super) fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
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..9cd0b72aa 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -2,6 +2,7 @@
 use std::{ops, sync::Arc};
+use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
 use hir_expand::{hygiene::Hygiene, AstId, InFile};
@@ -38,12 +39,16 @@ impl From<Documentation> for String {
    }
 }
+/// Syntactical attributes, without filtering of `cfg_attr`s.
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct Attrs {
+pub 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 +59,88 @@ 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 const EMPTY: Self = Self { entries: None };
+    pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Self {
+        let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
+            .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
+        let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
+        let attrs = outer_attrs
+            .chain(inner_attrs.into_iter().flatten())
+            .map(|attr| (attr.syntax().text_range().start(), Attr::from_src(attr, hygiene)));
+        let outer_docs =
+            ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
+        let docs = outer_docs.chain(inner_docs.into_iter().flatten()).map(|docs_text| {
+            (
+                docs_text.syntax().text_range().start(),
+                docs_text.doc_comment().map(|doc| Attr {
+                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    path: ModPath::from(hir_expand::name!(doc)),
+                }),
+            )
+        });
+        // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
+        let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+        let entries = if attrs.is_empty() {
+            // Avoid heap allocation
+            None
+        } else {
+            Some(attrs.into_iter().flat_map(|(_, attr)| 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 {
+        // FIXME actually implement this
+        Attrs(self)
+    }
+}
 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 +152,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,53 +175,19 @@ 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 }
+        raw_attrs.filter(db, def.krate(db))
    }
    pub fn merge(&self, other: Attrs) -> Attrs {
-        match (&self.entries, &other.entries) {
+        match (&self.0.entries, &other.0.entries) {
-            (None, None) => Attrs { entries: None },
+            (None, None) => Attrs::EMPTY,
            (Some(entries), None) | (None, Some(entries)) => {
-                Attrs { entries: Some(entries.clone()) }
+                Attrs(RawAttrs { entries: Some(entries.clone()) })
            }
            (Some(a), Some(b)) => {
-                Attrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) }
+                Attrs(RawAttrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) })
            }
        }
    }
@@ -291,16 +331,16 @@ 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()
 }
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 bdba4c33e..0f404be1b 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -233,8 +233,7 @@ impl ExprCollector<'_> {
                        let res = self.collect_block(block);
                        match &mut self.body.exprs[res] {
                            Expr::Block { label: block_label, .. } => {
-                                *block_label =
+                                *block_label = label.lifetime().map(|t| Name::new_lifetime(&t))
-                                    label.lifetime_token().map(|t| Name::new_lifetime(&t))
                            }
                            _ => unreachable!(),
                        }
@@ -254,10 +253,7 @@ impl ExprCollector<'_> {
                self.alloc_expr(
                    Expr::Loop {
                        body,
-                        label: e
+                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                            .label()
-                            .and_then(|l| l.lifetime_token())
-                            .map(|l| Name::new_lifetime(&l)),
                    },
                    syntax_ptr,
                )
@@ -288,7 +284,7 @@ impl ExprCollector<'_> {
                                    body: match_expr,
                                    label: e
                                        .label()
-                                        .and_then(|l| l.lifetime_token())
+                                        .and_then(|l| l.lifetime())
                                        .map(|l| Name::new_lifetime(&l)),
                                },
                                syntax_ptr,
@@ -301,10 +297,7 @@ impl ExprCollector<'_> {
                    Expr::While {
                        condition,
                        body,
-                        label: e
+                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                            .label()
-                            .and_then(|l| l.lifetime_token())
-                            .map(|l| Name::new_lifetime(&l)),
                    },
                    syntax_ptr,
                )
@@ -318,10 +311,7 @@ impl ExprCollector<'_> {
                        iterable,
                        pat,
                        body,
-                        label: e
+                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                            .label()
-                            .and_then(|l| l.lifetime_token())
-                            .map(|l| Name::new_lifetime(&l)),
                    },
                    syntax_ptr,
                )
@@ -380,13 +370,13 @@ impl ExprCollector<'_> {
                self.alloc_expr(path, syntax_ptr)
            }
            ast::Expr::ContinueExpr(e) => self.alloc_expr(
-                Expr::Continue { label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
+                Expr::Continue { label: e.lifetime().map(|l| Name::new_lifetime(&l)) },
                syntax_ptr,
            ),
            ast::Expr::BreakExpr(e) => {
                let expr = e.expr().map(|e| self.collect_expr(e));
                self.alloc_expr(
-                    Expr::Break { expr, label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
+                    Expr::Break { expr, label: e.lifetime().map(|l| Name::new_lifetime(&l)) },
                    syntax_ptr,
                )
            }
@@ -772,7 +762,10 @@ impl ExprCollector<'_> {
                    | ast::Item::Module(_)
                    | ast::Item::MacroCall(_) => return None,
                    ast::Item::MacroRules(def) => {
-                        return Some(Either::Right(def));
+                        return Some(Either::Right(ast::Macro::from(def)));
+                    }
+                    ast::Item::MacroDef(def) => {
+                        return Some(Either::Right(ast::Macro::from(def)));
                    }
                };
@@ -800,7 +793,7 @@ impl ExprCollector<'_> {
                }
                Either::Right(e) => {
                    let mac = MacroDefId {
-                        krate: Some(self.expander.module.krate),
+                        krate: self.expander.module.krate,
                        ast_id: Some(self.expander.ast_id(&e)),
                        kind: MacroDefKind::Declarative,
                        local_inner: false,
@@ -970,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/db.rs b/crates/hir_def/src/db.rs
index 7f250da33..d1a459066 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -16,8 +16,8 @@ use crate::{
    lang_item::{LangItemTarget, LangItems},
    nameres::CrateDefMap,
    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
+    GenericDefId, ImplId, ImplLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
-    TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
 };
 #[salsa::query_group(InternDatabaseStorage)]
@@ -95,9 +95,6 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(Attrs::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> Attrs;
-    #[salsa::invoke(LangItems::module_lang_items_query)]
-    fn module_lang_items(&self, module: ModuleId) -> Option<Arc<LangItems>>;
    #[salsa::invoke(LangItems::crate_lang_items_query)]
    fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 924046435..41134d23b 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -260,9 +260,8 @@ impl GenericParams {
            self.fill_bounds(&lower_ctx, &type_param, Either::Left(type_ref));
        }
        for lifetime_param in params.lifetime_params() {
-            let name = lifetime_param
+            let name =
-                .lifetime_token()
+                lifetime_param.lifetime().map_or_else(Name::missing, |lt| Name::new_lifetime(&lt));
-                .map_or_else(Name::missing, |tok| Name::new_lifetime(&tok));
            let param = LifetimeParamData { name: name.clone() };
            let param_id = self.lifetimes.alloc(param);
            sm.lifetime_params.insert(param_id, lifetime_param.clone());
@@ -275,8 +274,8 @@ impl GenericParams {
        for pred in where_clause.predicates() {
            let target = if let Some(type_ref) = pred.ty() {
                Either::Left(TypeRef::from_ast(lower_ctx, type_ref))
-            } else if let Some(lifetime_tok) = pred.lifetime_token() {
+            } else if let Some(lifetime) = pred.lifetime() {
-                Either::Right(LifetimeRef::from_token(lifetime_tok))
+                Either::Right(LifetimeRef::new(&lifetime))
            } else {
                continue;
            };
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index a8b3fe844..62ab3b2bd 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -363,7 +363,7 @@ impl ItemInNs {
                ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
                ModuleDefId::BuiltinType(_) => return None,
            },
-            ItemInNs::Macros(id) => return id.krate,
+            ItemInNs::Macros(id) => return Some(id.krate),
        })
    }
 }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 1c9babf37..5eb7cae7f 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -13,6 +13,7 @@ use std::{
 use arena::{Arena, Idx, RawId};
 use ast::{AstNode, AttrsOwner, 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) => {
@@ -143,6 +144,7 @@ impl ItemTree {
                mods,
                macro_calls,
                macro_rules,
+                macro_defs,
                exprs,
                vis,
                generics,
@@ -164,6 +166,7 @@ impl ItemTree {
            mods.shrink_to_fit();
            macro_calls.shrink_to_fit();
            macro_rules.shrink_to_fit();
+            macro_defs.shrink_to_fit();
            exprs.shrink_to_fit();
            vis.arena.shrink_to_fit();
@@ -178,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.
@@ -283,6 +290,7 @@ struct ItemTreeData {
    mods: Arena<Mod>,
    macro_calls: Arena<MacroCall>,
    macro_rules: Arena<MacroRules>,
+    macro_defs: Arena<MacroDef>,
    exprs: Arena<Expr>,
    vis: ItemVisibilities,
@@ -431,6 +439,7 @@ mod_items! {
    Mod in mods -> ast::Module,
    MacroCall in macro_calls -> ast::MacroCall,
    MacroRules in macro_rules -> ast::MacroRules,
+    MacroDef in macro_defs -> ast::MacroDef,
 }
 macro_rules! impl_index {
@@ -640,17 +649,19 @@ pub struct MacroCall {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MacroRules {
-    /// For `macro_rules!` declarations, this is the name of the declared macro.
+    /// The name of the declared macro.
    pub name: Name,
-    /// Has `#[macro_export]`.
-    pub is_export: bool,
-    /// Has `#[macro_export(local_inner_macros)]`.
-    pub is_local_inner: bool,
-    /// Has `#[rustc_builtin_macro]`.
-    pub is_builtin: bool,
    pub ast_id: FileAstId<ast::MacroRules>,
 }
+/// "Macros 2.0" macro definition.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct MacroDef {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub ast_id: FileAstId<ast::MacroDef>,
+}
 // NB: There's no `FileAstId` for `Expr`. The only case where this would be useful is for array
 // lengths, but we don't do much with them yet.
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -680,7 +691,8 @@ impl ModItem {
            | ModItem::Trait(_)
            | ModItem::Impl(_)
            | ModItem::Mod(_)
-            | ModItem::MacroRules(_) => None,
+            | ModItem::MacroRules(_)
+            | ModItem::MacroDef(_) => None,
            ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)),
            ModItem::Const(konst) => Some(AssocItem::Const(*konst)),
            ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)),
@@ -708,6 +720,7 @@ impl ModItem {
            ModItem::Mod(it) => tree[it.index].ast_id().upcast(),
            ModItem::MacroCall(it) => tree[it.index].ast_id().upcast(),
            ModItem::MacroRules(it) => tree[it.index].ast_id().upcast(),
+            ModItem::MacroDef(it) => tree[it.index].ast_id().upcast(),
        }
    }
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index b39d7fb7a..c8f090c22 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,
 };
@@ -101,10 +100,11 @@ impl Ctx {
            | ast::Item::ExternCrate(_)
            | ast::Item::Use(_)
            | ast::Item::MacroCall(_)
-            | ast::Item::MacroRules(_) => {}
+            | ast::Item::MacroRules(_)
+            | 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),
@@ -122,6 +122,7 @@ impl Ctx {
            ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into),
            ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
            ast::Item::MacroRules(ast) => self.lower_macro_rules(ast).map(Into::into),
+            ast::Item::MacroDef(ast) => self.lower_macro_def(ast).map(Into::into),
            ast::Item::ExternBlock(ast) => {
                Some(ModItems(self.lower_extern_block(ast).into_iter().collect::<SmallVec<_>>()))
            }
@@ -136,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);
@@ -203,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();
@@ -223,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)
@@ -268,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();
@@ -298,12 +299,12 @@ impl Ctx {
                            ast::SelfParamKind::Owned => self_type,
                            ast::SelfParamKind::Ref => TypeRef::Reference(
                                Box::new(self_type),
-                                self_param.lifetime_token().map(LifetimeRef::from_token),
+                                self_param.lifetime().as_ref().map(LifetimeRef::new),
                                Mutability::Shared,
                            ),
                            ast::SelfParamKind::MutRef => TypeRef::Reference(
                                Box::new(self_type),
-                                self_param.lifetime_token().map(LifetimeRef::from_token),
+                                self_param.lifetime().as_ref().map(LifetimeRef::new),
                                Mutability::Mut,
                            ),
                        }
@@ -436,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);
@@ -473,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)
            })
@@ -537,28 +538,20 @@ impl Ctx {
    fn lower_macro_rules(&mut self, m: &ast::MacroRules) -> Option<FileItemTreeId<MacroRules>> {
        let name = m.name().map(|it| it.as_name())?;
-        let attrs = Attrs::new(m, &self.hygiene);
        let ast_id = self.source_ast_id_map.ast_id(m);
-        // FIXME: cfg_attr
+        let res = MacroRules { name, ast_id };
-        let export_attr = attrs.by_key("macro_export");
+        Some(id(self.data().macro_rules.alloc(res)))
+    }
-        let is_export = export_attr.exists();
+    fn lower_macro_def(&mut self, m: &ast::MacroDef) -> Option<FileItemTreeId<MacroDef>> {
-        let is_local_inner = if is_export {
+        let name = m.name().map(|it| it.as_name())?;
-            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
-                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
-                    ident.text.contains("local_inner_macros")
-                }
-                _ => false,
-            })
-        } else {
-            false
-        };
-        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
+        let ast_id = self.source_ast_id_map.ast_id(m);
-        let res = MacroRules { name, is_export, is_builtin, is_local_inner, ast_id };
+        let visibility = self.lower_visibility(m);
-        Some(id(self.data().macro_rules.alloc(res)))
+        let res = MacroDef { name, ast_id, visibility };
+        Some(id(self.data().macro_defs.alloc(res)))
    }
    fn lower_extern_block(&mut self, block: &ast::ExternBlock) -> Vec<ModItem> {
@@ -566,7 +559,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/lang_item.rs b/crates/hir_def/src/lang_item.rs
index 063eadccb..30188b740 100644
--- a/crates/hir_def/src/lang_item.rs
+++ b/crates/hir_def/src/lang_item.rs
@@ -8,8 +8,8 @@ use rustc_hash::FxHashMap;
 use syntax::SmolStr;
 use crate::{
-    db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, ModuleId,
+    db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, StaticId,
-    StaticId, StructId, TraitId,
+    StructId, TraitId,
 };
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -84,27 +84,34 @@ impl LangItems {
        let crate_def_map = db.crate_def_map(krate);
-        crate_def_map
+        for (_, module_data) in crate_def_map.modules.iter() {
-            .modules
+            for impl_def in module_data.scope.impls() {
-            .iter()
+                lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
-            .filter_map(|(local_id, _)| db.module_lang_items(ModuleId { krate, local_id }))
+            }
-            .for_each(|it| lang_items.items.extend(it.items.iter().map(|(k, v)| (k.clone(), *v))));
-        Arc::new(lang_items)
-    }
-    pub(crate) fn module_lang_items_query(
+            for def in module_data.scope.declarations() {
-        db: &dyn DefDatabase,
+                match def {
-        module: ModuleId,
+                    ModuleDefId::TraitId(trait_) => {
-    ) -> Option<Arc<LangItems>> {
+                        lang_items.collect_lang_item(db, trait_, LangItemTarget::TraitId)
-        let _p = profile::span("module_lang_items_query");
+                    }
-        let mut lang_items = LangItems::default();
+                    ModuleDefId::AdtId(AdtId::EnumId(e)) => {
-        lang_items.collect_lang_items(db, module);
+                        lang_items.collect_lang_item(db, e, LangItemTarget::EnumId)
-        if lang_items.items.is_empty() {
+                    }
-            None
+                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
-        } else {
+                        lang_items.collect_lang_item(db, s, LangItemTarget::StructId)
-            Some(Arc::new(lang_items))
+                    }
+                    ModuleDefId::FunctionId(f) => {
+                        lang_items.collect_lang_item(db, f, LangItemTarget::FunctionId)
+                    }
+                    ModuleDefId::StaticId(s) => {
+                        lang_items.collect_lang_item(db, s, LangItemTarget::StaticId)
+                    }
+                    _ => {}
+                }
+            }
        }
+        Arc::new(lang_items)
    }
    /// Salsa query. Look for a lang item, starting from the specified crate and recursively
@@ -126,34 +133,6 @@ impl LangItems {
            .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
    }
-    fn collect_lang_items(&mut self, db: &dyn DefDatabase, module: ModuleId) {
-        // Look for impl targets
-        let def_map = db.crate_def_map(module.krate);
-        let module_data = &def_map[module.local_id];
-        for impl_def in module_data.scope.impls() {
-            self.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
-        }
-        for def in module_data.scope.declarations() {
-            match def {
-                ModuleDefId::TraitId(trait_) => {
-                    self.collect_lang_item(db, trait_, LangItemTarget::TraitId)
-                }
-                ModuleDefId::AdtId(AdtId::EnumId(e)) => {
-                    self.collect_lang_item(db, e, LangItemTarget::EnumId)
-                }
-                ModuleDefId::AdtId(AdtId::StructId(s)) => {
-                    self.collect_lang_item(db, s, LangItemTarget::StructId)
-                }
-                ModuleDefId::FunctionId(f) => {
-                    self.collect_lang_item(db, f, LangItemTarget::FunctionId)
-                }
-                ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::StaticId),
-                _ => {}
-            }
-        }
-    }
    fn collect_lang_item<T>(
        &mut self,
        db: &dyn DefDatabase,
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 {
    fn as_call_id(
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 85cc342c4..b114a6fe4 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -26,7 +26,8 @@ use crate::{
    db::DefDatabase,
    item_scope::{ImportType, PerNsGlobImports},
    item_tree::{
-        self, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind, StructDefKind,
+        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind,
+        StructDefKind,
    },
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
@@ -220,17 +221,20 @@ impl DefCollector<'_> {
        let item_tree = self.db.item_tree(file_id.into());
        let module_id = self.def_map.root;
        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
-        let mut root_collector = ModCollector {
+        if item_tree
-            def_collector: &mut *self,
+            .top_level_attrs(self.db, self.def_map.krate)
-            macro_depth: 0,
+            .cfg()
-            module_id,
+            .map_or(true, |cfg| self.cfg_options.check(&cfg) != Some(false))
-            file_id: file_id.into(),
-            item_tree: &item_tree,
-            mod_dir: ModDir::root(),
-        };
-        if item_tree.top_level_attrs().cfg().map_or(true, |cfg| root_collector.is_cfg_enabled(&cfg))
        {
-            root_collector.collect(item_tree.top_level_items());
+            ModCollector {
+                def_collector: &mut *self,
+                macro_depth: 0,
+                module_id,
+                file_id: file_id.into(),
+                item_tree: &item_tree,
+                mod_dir: ModDir::root(),
+            }
+            .collect(item_tree.top_level_items());
        }
        // main name resolution fixed-point loop.
@@ -309,13 +313,13 @@ impl DefCollector<'_> {
        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == name) {
            Some((_, expander)) => MacroDefId {
                ast_id: None,
-                krate: Some(self.def_map.krate),
+                krate: self.def_map.krate,
                kind: MacroDefKind::ProcMacro(*expander),
                local_inner: false,
            },
            None => MacroDefId {
                ast_id: None,
-                krate: Some(self.def_map.krate),
+                krate: self.def_map.krate,
                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate)),
                local_inner: false,
            },
@@ -784,14 +788,6 @@ impl DefCollector<'_> {
        directive: &DeriveDirective,
        path: &ModPath,
    ) -> Option<MacroDefId> {
-        if let Some(name) = path.as_ident() {
-            // FIXME this should actually be handled with the normal name
-            // resolution; the std lib defines built-in stubs for the derives,
-            // but these are new-style `macro`s, which we don't support yet
-            if let Some(def_id) = find_builtin_derive(name) {
-                return Some(def_id);
-            }
-        }
        let resolved_res = self.def_map.resolve_path_fp_with_macro(
            self.db,
            ResolveMode::Other,
@@ -912,6 +908,8 @@ struct ModCollector<'a, 'b> {
 impl ModCollector<'_, '_> {
    fn collect(&mut self, items: &[ModItem]) {
+        let krate = self.def_collector.def_map.krate;
        // Note: don't assert that inserted value is fresh: it's simply not true
        // for macros.
        self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone());
@@ -928,7 +926,7 @@ impl ModCollector<'_, '_> {
        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
        // any other items.
        for item in items {
-            let attrs = self.item_tree.attrs((*item).into());
+            let attrs = self.item_tree.attrs(self.def_collector.db, krate, (*item).into());
            if attrs.cfg().map_or(true, |cfg| self.is_cfg_enabled(&cfg)) {
                if let ModItem::ExternCrate(id) = item {
                    let import = self.item_tree[*id].clone();
@@ -940,7 +938,7 @@ impl ModCollector<'_, '_> {
        }
        for &item in items {
-            let attrs = self.item_tree.attrs(item.into());
+            let attrs = self.item_tree.attrs(self.def_collector.db, krate, item.into());
            if let Some(cfg) = attrs.cfg() {
                if !self.is_cfg_enabled(&cfg) {
                    self.emit_unconfigured_diagnostic(item, &cfg);
@@ -953,7 +951,7 @@ impl ModCollector<'_, '_> {
            let mut def = None;
            match item {
-                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
+                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], &attrs),
                ModItem::Import(import_id) => {
                    self.def_collector.unresolved_imports.push(ImportDirective {
                        module_id: self.module_id,
@@ -975,7 +973,41 @@ impl ModCollector<'_, '_> {
                    })
                }
                ModItem::MacroCall(mac) => self.collect_macro_call(&self.item_tree[mac]),
-                ModItem::MacroRules(mac) => self.collect_macro_rules(&self.item_tree[mac]),
+                ModItem::MacroRules(id) => self.collect_macro_rules(id),
+                ModItem::MacroDef(id) => {
+                    let mac = &self.item_tree[id];
+                    let ast_id = InFile::new(self.file_id, mac.ast_id.upcast());
+                    // "Macro 2.0" is not currently supported by rust-analyzer, but libcore uses it
+                    // to define builtin macros, so we support at least that part.
+                    let attrs = self.item_tree.attrs(
+                        self.def_collector.db,
+                        krate,
+                        ModItem::from(id).into(),
+                    );
+                    if attrs.by_key("rustc_builtin_macro").exists() {
+                        let krate = self.def_collector.def_map.krate;
+                        let macro_id = find_builtin_macro(&mac.name, krate, ast_id)
+                            .or_else(|| find_builtin_derive(&mac.name, krate, ast_id));
+                        if let Some(macro_id) = macro_id {
+                            let vis = self
+                                .def_collector
+                                .def_map
+                                .resolve_visibility(
+                                    self.def_collector.db,
+                                    self.module_id,
+                                    &self.item_tree[mac.visibility],
+                                )
+                                .unwrap_or(Visibility::Public);
+                            self.def_collector.update(
+                                self.module_id,
+                                &[(Some(mac.name.clone()), PerNs::macros(macro_id, vis))],
+                                vis,
+                                ImportType::Named,
+                            );
+                        }
+                    }
+                }
                ModItem::Impl(imp) => {
                    let module = ModuleId {
                        krate: self.def_collector.def_map.krate,
@@ -989,7 +1021,7 @@ impl ModCollector<'_, '_> {
                ModItem::Function(id) => {
                    let func = &self.item_tree[id];
-                    self.collect_proc_macro_def(&func.name, attrs);
+                    self.collect_proc_macro_def(&func.name, &attrs);
                    def = Some(DefData {
                        id: FunctionLoc {
@@ -1009,7 +1041,7 @@ impl ModCollector<'_, '_> {
                    // FIXME: check attrs to see if this is an attribute macro invocation;
                    // in which case we don't add the invocation, just a single attribute
                    // macro invocation
-                    self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
                        id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
@@ -1026,7 +1058,7 @@ impl ModCollector<'_, '_> {
                    // FIXME: check attrs to see if this is an attribute macro invocation;
                    // in which case we don't add the invocation, just a single attribute
                    // macro invocation
-                    self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
                        id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
@@ -1043,7 +1075,7 @@ impl ModCollector<'_, '_> {
                    // FIXME: check attrs to see if this is an attribute macro invocation;
                    // in which case we don't add the invocation, just a single attribute
                    // macro invocation
-                    self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
                        id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
@@ -1279,18 +1311,35 @@ impl ModCollector<'_, '_> {
        self.def_collector.resolve_proc_macro(&macro_name);
    }
-    fn collect_macro_rules(&mut self, mac: &MacroRules) {
+    fn collect_macro_rules(&mut self, id: FileItemTreeId<MacroRules>) {
-        let ast_id = InFile::new(self.file_id, mac.ast_id);
+        let krate = self.def_collector.def_map.krate;
+        let mac = &self.item_tree[id];
+        let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());
+        let ast_id = InFile::new(self.file_id, mac.ast_id.upcast());
+        let export_attr = attrs.by_key("macro_export");
+        let is_export = export_attr.exists();
+        let is_local_inner = if is_export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
        // Case 1: builtin macros
-        if mac.is_builtin {
+        if attrs.by_key("rustc_builtin_macro").exists() {
            let krate = self.def_collector.def_map.krate;
            if let Some(macro_id) = find_builtin_macro(&mac.name, krate, ast_id) {
                self.def_collector.define_macro(
                    self.module_id,
                    mac.name.clone(),
                    macro_id,
-                    mac.is_export,
+                    is_export,
                );
                return;
            }
@@ -1299,11 +1348,11 @@ impl ModCollector<'_, '_> {
        // Case 2: normal `macro_rules!` macro
        let macro_id = MacroDefId {
            ast_id: Some(ast_id),
-            krate: Some(self.def_collector.def_map.krate),
+            krate: self.def_collector.def_map.krate,
            kind: MacroDefKind::Declarative,
-            local_inner: mac.is_local_inner,
+            local_inner: is_local_inner,
        };
-        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, mac.is_export);
+        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, is_export);
    }
    fn collect_macro_call(&mut self, mac: &MacroCall) {
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index 305fca0f9..6fe2ee78a 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -633,15 +633,44 @@ pub struct bar;
 fn expand_derive() {
    let map = compute_crate_def_map(
        "
-        //- /main.rs
+        //- /main.rs crate:main deps:core
+        use core::*;
        #[derive(Copy, Clone)]
        struct Foo;
+        //- /core.rs crate:core
+        #[rustc_builtin_macro]
+        pub macro Copy {}
+        #[rustc_builtin_macro]
+        pub macro Clone {}
        ",
    );
    assert_eq!(map.modules[map.root].scope.impls().len(), 2);
 }
 #[test]
+fn resolve_builtin_derive() {
+    check(
+        r#"
+//- /main.rs crate:main deps:core
+use core::*;
+//- /core.rs crate:core
+#[rustc_builtin_macro]
+pub macro Clone {}
+pub trait Clone {}
+"#,
+        expect![[r#"
+            crate
+            Clone: t m
+        "#]],
+    );
+}
+#[test]
 fn macro_expansion_overflow() {
    mark::check!(macro_expansion_overflow);
    check(
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 609925012..8a01e6eea 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -169,8 +169,8 @@ pub(super) fn lower_generic_args(
                }
            }
            ast::GenericArg::LifetimeArg(lifetime_arg) => {
-                if let Some(lifetime) = lifetime_arg.lifetime_token() {
+                if let Some(lifetime) = lifetime_arg.lifetime() {
-                    let lifetime_ref = LifetimeRef::from_token(lifetime);
+                    let lifetime_ref = LifetimeRef::new(&lifetime);
                    args.push(GenericArg::Lifetime(lifetime_ref))
                }
            }
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index 347ceabb9..ae93d0d10 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -1,7 +1,7 @@
 //! HIR for references to types. Paths in these are not yet resolved. They can
 //! be directly created from an ast::TypeRef, without further queries.
 use hir_expand::name::Name;
-use syntax::{ast, SyntaxToken};
+use syntax::ast;
 use crate::{body::LowerCtx, path::Path};
@@ -80,8 +80,8 @@ impl LifetimeRef {
        LifetimeRef { name }
    }
-    pub(crate) fn from_token(token: SyntaxToken) -> Self {
+    pub(crate) fn new(lifetime: &ast::Lifetime) -> Self {
-        LifetimeRef { name: Name::new_lifetime(&token) }
+        LifetimeRef { name: Name::new_lifetime(lifetime) }
    }
    pub fn missing() -> LifetimeRef {
@@ -127,7 +127,7 @@ impl TypeRef {
            }
            ast::Type::RefType(inner) => {
                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.ty());
-                let lifetime = inner.lifetime_token().map(|t| LifetimeRef::from_token(t));
+                let lifetime = inner.lifetime().map(|lt| LifetimeRef::new(&lt));
                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                TypeRef::Reference(Box::new(inner_ty), lifetime, mutability)
            }
@@ -259,7 +259,7 @@ impl TypeBound {
            }
            ast::TypeBoundKind::ForType(_) => TypeBound::Error, // FIXME ForType
            ast::TypeBoundKind::Lifetime(lifetime) => {
-                TypeBound::Lifetime(LifetimeRef::from_token(lifetime))
+                TypeBound::Lifetime(LifetimeRef::new(&lifetime))
            }
        }
    }
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index 988a60d56..ad378762a 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -8,7 +8,7 @@ use syntax::{
    match_ast,
 };
-use crate::{db::AstDatabase, name, quote, LazyMacroId, MacroDefId, MacroDefKind};
+use crate::{db::AstDatabase, name, quote, AstId, CrateId, LazyMacroId, MacroDefId, MacroDefKind};
 macro_rules! register_builtin {
    ( $($trait:ident => $expand:ident),* ) => {
@@ -29,16 +29,15 @@ macro_rules! register_builtin {
                };
                expander(db, id, tt)
            }
-        }
-        pub fn find_builtin_derive(ident: &name::Name) -> Option<MacroDefId> {
-            let kind = match ident {
-                $( id if id == &name::name![$trait] => BuiltinDeriveExpander::$trait, )*
-                 _ => return None,
-            };
-            Some(MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(kind), local_inner: false })
+            fn find_by_name(name: &name::Name) -> Option<Self> {
+                match name {
+                    $( id if id == &name::name![$trait] => Some(BuiltinDeriveExpander::$trait), )*
+                     _ => None,
+                }
+            }
        }
    };
 }
@@ -54,6 +53,20 @@ register_builtin! {
    PartialEq => partial_eq_expand
 }
+pub fn find_builtin_derive(
+    ident: &name::Name,
+    krate: CrateId,
+    ast_id: AstId<ast::Macro>,
+) -> Option<MacroDefId> {
+    let expander = BuiltinDeriveExpander::find_by_name(ident)?;
+    Some(MacroDefId {
+        krate,
+        ast_id: Some(ast_id),
+        kind: MacroDefKind::BuiltInDerive(expander),
+        local_inner: false,
+    })
+}
 struct BasicAdtInfo {
    name: tt::Ident,
    type_params: usize,
@@ -261,7 +274,7 @@ mod tests {
    use super::*;
    fn expand_builtin_derive(s: &str, name: Name) -> String {
-        let def = find_builtin_derive(&name).unwrap();
+        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
        let fixture = format!(
            r#"//- /main.rs crate:main deps:core
 <|>
@@ -283,7 +296,12 @@ mod tests {
        let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
        let loc = MacroCallLoc {
-            def,
+            def: MacroDefId {
+                krate: CrateId(0),
+                ast_id: None,
+                kind: MacroDefKind::BuiltInDerive(expander),
+                local_inner: false,
+            },
            krate: CrateId(0),
            kind: MacroCallKind::Attr(attr_id, name.to_string()),
        };
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index bd9223825..dddbbcdac 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -63,19 +63,19 @@ macro_rules! register_builtin {
 pub fn find_builtin_macro(
    ident: &name::Name,
    krate: CrateId,
-    ast_id: AstId<ast::MacroRules>,
+    ast_id: AstId<ast::Macro>,
 ) -> Option<MacroDefId> {
    let kind = find_by_name(ident)?;
    match kind {
        Either::Left(kind) => Some(MacroDefId {
-            krate: Some(krate),
+            krate,
            ast_id: Some(ast_id),
            kind: MacroDefKind::BuiltIn(kind),
            local_inner: false,
        }),
        Either::Right(kind) => Some(MacroDefId {
-            krate: Some(krate),
+            krate,
            ast_id: Some(ast_id),
            kind: MacroDefKind::BuiltInEager(kind),
            local_inner: false,
@@ -515,24 +515,27 @@ mod tests {
    fn expand_builtin_macro(ra_fixture: &str) -> String {
        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
        let parsed = db.parse(file_id);
-        let macro_rules: Vec<_> =
+        let mut macro_rules: Vec<_> =
            parsed.syntax_node().descendants().filter_map(ast::MacroRules::cast).collect();
-        let macro_calls: Vec<_> =
+        let mut macro_calls: Vec<_> =
            parsed.syntax_node().descendants().filter_map(ast::MacroCall::cast).collect();
        let ast_id_map = db.ast_id_map(file_id.into());
        assert_eq!(macro_rules.len(), 1, "test must contain exactly 1 `macro_rules!`");
        assert_eq!(macro_calls.len(), 1, "test must contain exactly 1 macro call");
-        let expander = find_by_name(&macro_rules[0].name().unwrap().as_name()).unwrap();
+        let macro_rules = ast::Macro::from(macro_rules.pop().unwrap());
+        let macro_call = macro_calls.pop().unwrap();
+        let expander = find_by_name(&macro_rules.name().unwrap().as_name()).unwrap();
        let krate = CrateId(0);
        let file_id = match expander {
            Either::Left(expander) => {
                // the first one should be a macro_rules
                let def = MacroDefId {
-                    krate: Some(CrateId(0)),
+                    krate: CrateId(0),
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules[0]))),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules))),
                    kind: MacroDefKind::BuiltIn(expander),
                    local_inner: false,
                };
@@ -542,7 +545,7 @@ mod tests {
                    krate,
                    kind: MacroCallKind::FnLike(AstId::new(
                        file_id.into(),
-                        ast_id_map.ast_id(&macro_calls[0]),
+                        ast_id_map.ast_id(&macro_call),
                    )),
                };
@@ -552,13 +555,13 @@ mod tests {
            Either::Right(expander) => {
                // the first one should be a macro_rules
                let def = MacroDefId {
-                    krate: Some(krate),
+                    krate,
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules[0]))),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules))),
                    kind: MacroDefKind::BuiltInEager(expander),
                    local_inner: false,
                };
-                let args = macro_calls[0].token_tree().unwrap();
+                let args = macro_call.token_tree().unwrap();
                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
                let arg_id = db.intern_eager_expansion({
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 11b5b98c8..4477d867f 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -129,7 +129,10 @@ fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
        MacroDefKind::Declarative => {
-            let macro_call = id.ast_id?.to_node(db);
+            let macro_call = match id.ast_id?.to_node(db) {
+                syntax::ast::Macro::MacroRules(mac) => mac,
+                syntax::ast::Macro::MacroDef(_) => return None,
+            };
            let arg = macro_call.token_tree()?;
            let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
                log::warn!("fail on macro_def to token tree: {:#?}", arg);
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 5d3fa0518..7ab0a5e52 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -29,8 +29,8 @@ impl Hygiene {
                MacroCallId::LazyMacro(id) => {
                    let loc = db.lookup_intern_macro(id);
                    match loc.def.kind {
-                        MacroDefKind::Declarative => (loc.def.krate, loc.def.local_inner),
+                        MacroDefKind::Declarative => (Some(loc.def.krate), loc.def.local_inner),
-                        MacroDefKind::BuiltIn(_) => (loc.def.krate, false),
+                        MacroDefKind::BuiltIn(_) => (Some(loc.def.krate), false),
                        MacroDefKind::BuiltInDerive(_) => (None, false),
                        MacroDefKind::BuiltInEager(_) => (None, false),
                        MacroDefKind::ProcMacro(_) => (None, false),
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index ae3086a95..d486186e5 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -145,7 +145,10 @@ impl HirFileId {
                let arg_tt = loc.kind.arg(db)?;
                let def = loc.def.ast_id.and_then(|id| {
-                    let def_tt = id.to_node(db).token_tree()?;
+                    let def_tt = match id.to_node(db) {
+                        ast::Macro::MacroRules(mac) => mac.token_tree()?,
+                        ast::Macro::MacroDef(_) => return None,
+                    };
                    Some(InFile::new(id.file_id, def_tt))
                });
@@ -221,14 +224,8 @@ impl From<EagerMacroId> for MacroCallId {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDefId {
-    // FIXME: krate and ast_id are currently optional because we don't have a
+    pub krate: CrateId,
-    // definition location for built-in derives. There is one, though: the
+    pub ast_id: Option<AstId<ast::Macro>>,
-    // standard library defines them. The problem is that it uses the new
-    // `macro` syntax for this, which we don't support yet. As soon as we do
-    // (which will probably require touching this code), we can instead use
-    // that (and also remove the hacks for resolving built-in derives).
-    pub krate: Option<CrateId>,
-    pub ast_id: Option<AstId<ast::MacroRules>>,
    pub kind: MacroDefKind,
    pub local_inner: bool,
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 69d8e6803..7fb4caea3 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -37,9 +37,8 @@ impl Name {
        Name(Repr::TupleField(idx))
    }
-    pub fn new_lifetime(lt: &syntax::SyntaxToken) -> Name {
+    pub fn new_lifetime(lt: &ast::Lifetime) -> Name {
-        assert_eq!(lt.kind(), syntax::SyntaxKind::LIFETIME);
+        Self::new_text(lt.text().clone())
-        Name(Repr::Text(lt.text().clone()))
    }
    /// Shortcut to create inline plain text name
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 1c72f766e..14e18f5a1 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -6,6 +6,7 @@ mod decl_check;
 use std::{any::Any, fmt};
+use base_db::CrateId;
 use hir_def::{DefWithBodyId, ModuleDefId};
 use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{name::Name, HirFileId, InFile};
@@ -18,12 +19,13 @@ pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern
 pub fn validate_module_item(
    db: &dyn HirDatabase,
+    krate: CrateId,
    owner: ModuleDefId,
    sink: &mut DiagnosticSink<'_>,
 ) {
    let _p = profile::span("validate_module_item");
-    let mut validator = decl_check::DeclValidator::new(owner, sink);
+    let mut validator = decl_check::DeclValidator::new(db, krate, sink);
-    validator.validate_item(db);
+    validator.validate_item(owner);
 }
 pub fn validate_body(db: &dyn HirDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
@@ -407,7 +409,7 @@ mod tests {
                for (module_id, _) in crate_def_map.modules.iter() {
                    for decl in crate_def_map[module_id].scope.declarations() {
                        let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-                        validate_module_item(self, decl, &mut sink);
+                        validate_module_item(self, krate, decl, &mut sink);
                        if let ModuleDefId::FunctionId(f) = decl {
                            fns.push(f)
@@ -419,7 +421,12 @@ mod tests {
                        for item in impl_data.items.iter() {
                            if let AssocItemId::FunctionId(f) = item {
                                let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-                                validate_module_item(self, ModuleDefId::FunctionId(*f), &mut sink);
+                                validate_module_item(
+                                    self,
+                                    krate,
+                                    ModuleDefId::FunctionId(*f),
+                                    &mut sink,
+                                );
                                fns.push(*f)
                            }
                        }
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 25587e116..eaeb6899f 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -12,6 +12,7 @@
 mod case_conv;
+use base_db::CrateId;
 use hir_def::{
    adt::VariantData,
    expr::{Pat, PatId},
@@ -40,7 +41,8 @@ mod allow {
 }
 pub(super) struct DeclValidator<'a, 'b: 'a> {
-    owner: ModuleDefId,
+    db: &'a dyn HirDatabase,
+    krate: CrateId,
    sink: &'a mut DiagnosticSink<'b>,
 }
@@ -53,26 +55,27 @@ struct Replacement {
 impl<'a, 'b> DeclValidator<'a, 'b> {
    pub(super) fn new(
-        owner: ModuleDefId,
+        db: &'a dyn HirDatabase,
+        krate: CrateId,
        sink: &'a mut DiagnosticSink<'b>,
    ) -> DeclValidator<'a, 'b> {
-        DeclValidator { owner, sink }
+        DeclValidator { db, krate, sink }
    }
-    pub(super) fn validate_item(&mut self, db: &dyn HirDatabase) {
+    pub(super) fn validate_item(&mut self, item: ModuleDefId) {
-        match self.owner {
+        match item {
-            ModuleDefId::FunctionId(func) => self.validate_func(db, func),
+            ModuleDefId::FunctionId(func) => self.validate_func(func),
-            ModuleDefId::AdtId(adt) => self.validate_adt(db, adt),
+            ModuleDefId::AdtId(adt) => self.validate_adt(adt),
-            ModuleDefId::ConstId(const_id) => self.validate_const(db, const_id),
+            ModuleDefId::ConstId(const_id) => self.validate_const(const_id),
-            ModuleDefId::StaticId(static_id) => self.validate_static(db, static_id),
+            ModuleDefId::StaticId(static_id) => self.validate_static(static_id),
            _ => return,
        }
    }
-    fn validate_adt(&mut self, db: &dyn HirDatabase, adt: AdtId) {
+    fn validate_adt(&mut self, adt: AdtId) {
        match adt {
-            AdtId::StructId(struct_id) => self.validate_struct(db, struct_id),
+            AdtId::StructId(struct_id) => self.validate_struct(struct_id),
-            AdtId::EnumId(enum_id) => self.validate_enum(db, enum_id),
+            AdtId::EnumId(enum_id) => self.validate_enum(enum_id),
            AdtId::UnionId(_) => {
                // Unions aren't yet supported by this validator.
            }
@@ -82,27 +85,27 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    /// Checks whether not following the convention is allowed for this item.
    ///
    /// Currently this method doesn't check parent attributes.
-    fn allowed(&self, db: &dyn HirDatabase, id: AttrDefId, allow_name: &str) -> bool {
+    fn allowed(&self, id: AttrDefId, allow_name: &str) -> bool {
-        db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
+        self.db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
    }
-    fn validate_func(&mut self, db: &dyn HirDatabase, func: FunctionId) {
+    fn validate_func(&mut self, func: FunctionId) {
-        let data = db.function_data(func);
+        let data = self.db.function_data(func);
        if data.is_extern {
            mark::hit!(extern_func_incorrect_case_ignored);
            return;
        }
-        let body = db.body(func.into());
+        let body = self.db.body(func.into());
        // Recursively validate inner scope items, such as static variables and constants.
        for (item_id, _) in body.item_scope.values() {
-            let mut validator = DeclValidator::new(item_id, self.sink);
+            let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
-            validator.validate_item(db);
+            validator.validate_item(item_id);
        }
        // Check whether non-snake case identifiers are allowed for this function.
-        if self.allowed(db, func.into(), allow::NON_SNAKE_CASE) {
+        if self.allowed(func.into(), allow::NON_SNAKE_CASE) {
            return;
        }
@@ -169,11 +172,10 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
        self.create_incorrect_case_diagnostic_for_func(
            func,
-            db,
            fn_name_replacement,
            fn_param_replacements,
        );
-        self.create_incorrect_case_diagnostic_for_variables(func, db, pats_replacements);
+        self.create_incorrect_case_diagnostic_for_variables(func, pats_replacements);
    }
    /// Given the information about incorrect names in the function declaration, looks up into the source code
@@ -181,7 +183,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn create_incorrect_case_diagnostic_for_func(
        &mut self,
        func: FunctionId,
-        db: &dyn HirDatabase,
        fn_name_replacement: Option<Replacement>,
        fn_param_replacements: Vec<Replacement>,
    ) {
@@ -190,8 +191,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        let fn_loc = func.lookup(db.upcast());
+        let fn_loc = func.lookup(self.db.upcast());
-        let fn_src = fn_loc.source(db.upcast());
+        let fn_src = fn_loc.source(self.db.upcast());
        // Diagnostic for function name.
        if let Some(replacement) = fn_name_replacement {
@@ -282,7 +283,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn create_incorrect_case_diagnostic_for_variables(
        &mut self,
        func: FunctionId,
-        db: &dyn HirDatabase,
        pats_replacements: Vec<(PatId, Replacement)>,
    ) {
        // XXX: only look at source_map if we do have missing fields
@@ -290,12 +290,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        let (_, source_map) = db.body_with_source_map(func.into());
+        let (_, source_map) = self.db.body_with_source_map(func.into());
        for (id, replacement) in pats_replacements {
            if let Ok(source_ptr) = source_map.pat_syntax(id) {
                if let Some(expr) = source_ptr.value.as_ref().left() {
-                    let root = source_ptr.file_syntax(db.upcast());
+                    let root = source_ptr.file_syntax(self.db.upcast());
                    if let ast::Pat::IdentPat(ident_pat) = expr.to_node(&root) {
                        let parent = match ident_pat.syntax().parent() {
                            Some(parent) => parent,
@@ -333,12 +333,11 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        }
    }
-    fn validate_struct(&mut self, db: &dyn HirDatabase, struct_id: StructId) {
+    fn validate_struct(&mut self, struct_id: StructId) {
-        let data = db.struct_data(struct_id);
+        let data = self.db.struct_data(struct_id);
-        let non_camel_case_allowed =
+        let non_camel_case_allowed = self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
-            self.allowed(db, struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
+        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE);
-        let non_snake_case_allowed = self.allowed(db, struct_id.into(), allow::NON_SNAKE_CASE);
        // Check the structure name.
        let struct_name = data.name.to_string();
@@ -379,7 +378,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
        self.create_incorrect_case_diagnostic_for_struct(
            struct_id,
-            db,
            struct_name_replacement,
            struct_fields_replacements,
        );
@@ -390,7 +388,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn create_incorrect_case_diagnostic_for_struct(
        &mut self,
        struct_id: StructId,
-        db: &dyn HirDatabase,
        struct_name_replacement: Option<Replacement>,
        struct_fields_replacements: Vec<Replacement>,
    ) {
@@ -399,8 +396,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        let struct_loc = struct_id.lookup(db.upcast());
+        let struct_loc = struct_id.lookup(self.db.upcast());
-        let struct_src = struct_loc.source(db.upcast());
+        let struct_src = struct_loc.source(self.db.upcast());
        if let Some(replacement) = struct_name_replacement {
            let ast_ptr = match struct_src.value.name() {
@@ -473,11 +470,11 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        }
    }
-    fn validate_enum(&mut self, db: &dyn HirDatabase, enum_id: EnumId) {
+    fn validate_enum(&mut self, enum_id: EnumId) {
-        let data = db.enum_data(enum_id);
+        let data = self.db.enum_data(enum_id);
        // Check whether non-camel case names are allowed for this enum.
-        if self.allowed(db, enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
+        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
            return;
        }
@@ -512,7 +509,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
        self.create_incorrect_case_diagnostic_for_enum(
            enum_id,
-            db,
            enum_name_replacement,
            enum_fields_replacements,
        )
@@ -523,7 +519,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn create_incorrect_case_diagnostic_for_enum(
        &mut self,
        enum_id: EnumId,
-        db: &dyn HirDatabase,
        enum_name_replacement: Option<Replacement>,
        enum_variants_replacements: Vec<Replacement>,
    ) {
@@ -532,8 +527,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        let enum_loc = enum_id.lookup(db.upcast());
+        let enum_loc = enum_id.lookup(self.db.upcast());
-        let enum_src = enum_loc.source(db.upcast());
+        let enum_src = enum_loc.source(self.db.upcast());
        if let Some(replacement) = enum_name_replacement {
            let ast_ptr = match enum_src.value.name() {
@@ -608,10 +603,10 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        }
    }
-    fn validate_const(&mut self, db: &dyn HirDatabase, const_id: ConstId) {
+    fn validate_const(&mut self, const_id: ConstId) {
-        let data = db.const_data(const_id);
+        let data = self.db.const_data(const_id);
-        if self.allowed(db, const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
            return;
        }
@@ -632,8 +627,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        };
-        let const_loc = const_id.lookup(db.upcast());
+        let const_loc = const_id.lookup(self.db.upcast());
-        let const_src = const_loc.source(db.upcast());
+        let const_src = const_loc.source(self.db.upcast());
        let ast_ptr = match const_src.value.name() {
            Some(name) => name,
@@ -652,14 +647,14 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        self.sink.push(diagnostic);
    }
-    fn validate_static(&mut self, db: &dyn HirDatabase, static_id: StaticId) {
+    fn validate_static(&mut self, static_id: StaticId) {
-        let data = db.static_data(static_id);
+        let data = self.db.static_data(static_id);
        if data.is_extern {
            mark::hit!(extern_static_incorrect_case_ignored);
            return;
        }
-        if self.allowed(db, static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
            return;
        }
@@ -680,8 +675,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        };
-        let static_loc = static_id.lookup(db.upcast());
+        let static_loc = static_id.lookup(self.db.upcast());
-        let static_src = static_loc.source(db.upcast());
+        let static_src = static_loc.source(self.db.upcast());
        let ast_ptr = match static_src.value.name() {
            Some(name) => name,
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index de97ec3c2..a7656b864 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -686,6 +686,8 @@ mod clone {
    trait Clone {
        fn clone(&self) -> Self;
    }
+    #[rustc_builtin_macro]
+    macro Clone {}
 }
 "#,
    );
@@ -702,6 +704,8 @@ mod clone {
    trait Clone {
        fn clone(&self) -> Self;
    }
+    #[rustc_builtin_macro]
+    macro Clone {}
 }
 #[derive(Clone)]
 pub struct S;
@@ -737,6 +741,8 @@ mod clone {
    trait Clone {
        fn clone(&self) -> Self;
    }
+    #[rustc_builtin_macro]
+    macro Clone {}
 }
 "#,
    );
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 73fc73619..48acb8c93 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -1,15 +1,13 @@
 //! FIXME: write short doc here
 use either::Either;
-use hir::{
+use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, ModuleSource};
-    AssocItem, Documentation, FieldSource, HasAttrs, HasSource, HirFileId, InFile, ModuleSource,
-};
 use ide_db::base_db::{FileId, SourceDatabase};
 use ide_db::{defs::Definition, RootDatabase};
 use syntax::{
    ast::{self, NameOwner},
    match_ast, AstNode, SmolStr,
-    SyntaxKind::{self, IDENT_PAT, TYPE_PARAM},
+    SyntaxKind::{self, IDENT_PAT, LIFETIME_PARAM, TYPE_PARAM},
    TextRange,
 };
@@ -119,25 +117,6 @@ impl NavigationTarget {
        )
    }
-    /// Allows `NavigationTarget` to be created from a `DocCommentsOwner` and a `NameOwner`
-    pub(crate) fn from_doc_commented(
-        db: &RootDatabase,
-        named: InFile<&dyn ast::NameOwner>,
-        node: InFile<&dyn ast::DocCommentsOwner>,
-    ) -> NavigationTarget {
-        let name =
-            named.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
-        let frange = node.map(|it| it.syntax()).original_file_range(db);
-        NavigationTarget::from_syntax(
-            frange.file_id,
-            name,
-            None,
-            frange.range,
-            node.value.syntax().kind(),
-        )
-    }
    fn from_syntax(
        file_id: FileId,
        name: SmolStr,
@@ -168,7 +147,7 @@ impl ToNav for FileSymbol {
            focus_range: self.name_range,
            container_name: self.container_name.clone(),
            description: description_from_symbol(db, self),
-            docs: docs_from_symbol(db, self),
+            docs: None,
        }
    }
 }
@@ -190,6 +169,7 @@ impl TryToNav for Definition {
            Definition::SelfType(it) => Some(it.to_nav(db)),
            Definition::Local(it) => Some(it.to_nav(db)),
            Definition::TypeParam(it) => Some(it.to_nav(db)),
+            Definition::LifetimeParam(it) => Some(it.to_nav(db)),
        }
    }
 }
@@ -252,7 +232,7 @@ impl ToNav for hir::Module {
    }
 }
-impl ToNav for hir::ImplDef {
+impl ToNav for hir::Impl {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
        let derive_attr = self.is_builtin_derive(db);
@@ -384,28 +364,21 @@ impl ToNav for hir::TypeParam {
    }
 }
-pub(crate) fn docs_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option<Documentation> {
+impl ToNav for hir::LifetimeParam {
-    let parse = db.parse(symbol.file_id);
+    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
-    let node = symbol.ptr.to_node(parse.tree().syntax());
+        let src = self.source(db);
-    let file_id = HirFileId::from(symbol.file_id);
+        let full_range = src.value.syntax().text_range();
+        NavigationTarget {
-    let it = match_ast! {
+            file_id: src.file_id.original_file(db),
-        match node {
+            name: self.name(db).to_string().into(),
-            ast::Fn(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            kind: LIFETIME_PARAM,
-            ast::Struct(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            full_range,
-            ast::Enum(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            focus_range: Some(full_range),
-            ast::Trait(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            container_name: None,
-            ast::Module(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            description: None,
-            ast::TypeAlias(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
+            docs: None,
-            ast::Const(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
-            ast::Static(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
-            ast::RecordField(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
-            ast::Variant(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
-            ast::MacroCall(it) => hir::Attrs::from_attrs_owner(db, InFile::new(file_id, &it)),
-            _ => return None,
        }
-    };
+    }
-    it.docs()
 }
 /// Get a description of a symbol.
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 10263537a..79c081cac 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -112,7 +112,7 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
                .as_assoc_item(db)