16 files changed, 325 insertions, 406 deletions
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index b1923bbf2..2c368f690 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -13,6 +13,7 @@ once_cell = "1.0.1"
 rustc-hash = "1.0"
 either = "1.5"
 anymap = "0.12"
+drop_bomb = "0.1.4"
 ra_arena = { path = "../ra_arena" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 7787cb87f..401fe0b9b 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -3,10 +3,13 @@
 mod lower;
 pub mod scope;
-use std::{ops::Index, sync::Arc};
+use std::{mem, ops::Index, sync::Arc};
+use drop_bomb::DropBomb;
 use either::Either;
-use hir_expand::{hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId};
+use hir_expand::{
+    ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId,
+};
 use ra_arena::{map::ArenaMap, Arena};
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
@@ -15,15 +18,16 @@ use crate::{
    db::DefDatabase,
    expr::{Expr, ExprId, Pat, PatId},
    nameres::{BuiltinShadowMode, CrateDefMap},
-    path::Path,
+    path::{ModPath, Path},
    src::HasSource,
-    DefWithBodyId, HasModule, Lookup, ModuleId,
+    DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId,
 };
 struct Expander {
    crate_def_map: Arc<CrateDefMap>,
    current_file_id: HirFileId,
    hygiene: Hygiene,
+    ast_id_map: Arc<AstIdMap>,
    module: ModuleId,
 }
@@ -31,7 +35,8 @@ impl Expander {
    fn new(db: &impl DefDatabase, current_file_id: HirFileId, module: ModuleId) -> Expander {
        let crate_def_map = db.crate_def_map(module.krate);
        let hygiene = Hygiene::new(db, current_file_id);
-        Expander { crate_def_map, current_file_id, hygiene, module }
+        let ast_id_map = db.ast_id_map(current_file_id);
+        Expander { crate_def_map, current_file_id, hygiene, ast_id_map, module }
    }
    fn enter_expand(
@@ -44,7 +49,7 @@ impl Expander {
            db.ast_id_map(self.current_file_id).ast_id(&macro_call),
        );
-        if let Some(path) = macro_call.path().and_then(|path| self.parse_path(path)) {
+        if let Some(path) = macro_call.path().and_then(|path| self.parse_mod_path(path)) {
            if let Some(def) = self.resolve_path_as_macro(db, &path) {
                let call_id = def.as_call_id(db, MacroCallKind::FnLike(ast_id));
                let file_id = call_id.as_file();
@@ -52,9 +57,14 @@ impl Expander {
                    if let Some(expr) = ast::Expr::cast(node) {
                        log::debug!("macro expansion {:#?}", expr.syntax());
-                        let mark = Mark { file_id: self.current_file_id };
+                        let mark = Mark {
+                            file_id: self.current_file_id,
+                            ast_id_map: mem::take(&mut self.ast_id_map),
+                            bomb: DropBomb::new("expansion mark dropped"),
+                        };
                        self.hygiene = Hygiene::new(db, file_id);
                        self.current_file_id = file_id;
+                        self.ast_id_map = db.ast_id_map(file_id);
                        return Some((mark, expr));
                    }
@@ -67,10 +77,11 @@ impl Expander {
        None
    }
-    fn exit(&mut self, db: &impl DefDatabase, mark: Mark) {
+    fn exit(&mut self, db: &impl DefDatabase, mut mark: Mark) {
        self.hygiene = Hygiene::new(db, mark.file_id);
        self.current_file_id = mark.file_id;
-        std::mem::forget(mark);
+        self.ast_id_map = mem::take(&mut mark.ast_id_map);
+        mark.bomb.defuse();
    }
    fn to_source<T>(&self, value: T) -> InFile<T> {
@@ -81,24 +92,27 @@ impl Expander {
        Path::from_src(path, &self.hygiene)
    }
-    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
+    fn parse_mod_path(&mut self, path: ast::Path) -> Option<ModPath> {
+        ModPath::from_src(path, &self.hygiene)
+    }
+    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &ModPath) -> Option<MacroDefId> {
        self.crate_def_map
-            .resolve_path(db, self.module.local_id, path.mod_path(), BuiltinShadowMode::Other)
+            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
            .0
            .take_macros()
    }
+    fn ast_id<N: AstNode>(&self, item: &N) -> AstId<N> {
+        let file_local_id = self.ast_id_map.ast_id(item);
+        AstId::new(self.current_file_id, file_local_id)
+    }
 }
 struct Mark {
    file_id: HirFileId,
-}
+    ast_id_map: Arc<AstIdMap>,
+    bomb: DropBomb,
-impl Drop for Mark {
-    fn drop(&mut self) {
-        if !std::thread::panicking() {
-            panic!("dropped mark")
-        }
-    }
 }
 /// The body of an item (function, const etc.).
@@ -115,6 +129,7 @@ pub struct Body {
    pub params: Vec<PatId>,
    /// The `ExprId` of the actual body expression.
    pub body_expr: ExprId,
+    pub defs: Vec<ModuleDefId>,
 }
 pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;
@@ -169,7 +184,7 @@ impl Body {
            }
        };
        let expander = Expander::new(db, file_id, module);
-        let (body, source_map) = Body::new(db, expander, params, body);
+        let (body, source_map) = Body::new(db, def, expander, params, body);
        (Arc::new(body), Arc::new(source_map))
    }
@@ -179,11 +194,12 @@ impl Body {
    fn new(
        db: &impl DefDatabase,
+        def: DefWithBodyId,
        expander: Expander,
        params: Option<ast::ParamList>,
        body: Option<ast::Expr>,
    ) -> (Body, BodySourceMap) {
-        lower::lower(db, expander, params, body)
+        lower::lower(db, def, expander, params, body)
    }
 }
@@ -213,6 +229,11 @@ impl BodySourceMap {
        self.expr_map.get(&src).cloned()
    }
+    pub fn field_init_shorthand_expr(&self, node: InFile<&ast::RecordField>) -> Option<ExprId> {
+        let src = node.map(|it| Either::Right(AstPtr::new(it)));
+        self.expr_map.get(&src).cloned()
+    }
    pub fn pat_syntax(&self, pat: PatId) -> Option<PatSource> {
        self.pat_map_back.get(pat).copied()
    }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 61193b4d8..853e17bae 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -2,11 +2,12 @@
 //! representation.
 use either::Either;
 use hir_expand::name::{name, AsName, Name};
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
-        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
+        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, ModuleItemOwner, NameOwner,
        TypeAscriptionOwner,
    },
    AstNode, AstPtr,
@@ -24,23 +25,28 @@ use crate::{
    path::GenericArgs,
    path::Path,
    type_ref::{Mutability, TypeRef},
+    ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId, StaticLoc,
+    StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 pub(super) fn lower(
    db: &impl DefDatabase,
+    def: DefWithBodyId,
    expander: Expander,
    params: Option<ast::ParamList>,
    body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
    ExprCollector {
-        expander,
        db,
+        def,
+        expander,
        source_map: BodySourceMap::default(),
        body: Body {
            exprs: Arena::default(),
            pats: Arena::default(),
            params: Vec::new(),
            body_expr: ExprId::dummy(),
+            defs: Vec::new(),
        },
    }
    .collect(params, body)
@@ -48,6 +54,7 @@ pub(super) fn lower(
 struct ExprCollector<DB> {
    db: DB,
+    def: DefWithBodyId,
    expander: Expander,
    body: Body,
@@ -466,6 +473,7 @@ where
            Some(block) => block,
            None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
        };
+        self.collect_block_items(&block);
        let statements = block
            .statements()
            .map(|s| match s {
@@ -482,6 +490,51 @@ where
        self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
    }
+    fn collect_block_items(&mut self, block: &ast::Block) {
+        let container = ContainerId::DefWithBodyId(self.def);
+        for item in block.items() {
+            let def: ModuleDefId = match item {
+                ast::ModuleItem::FnDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    FunctionLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::TypeAliasDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    TypeAliasLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::ConstDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    ConstLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::StaticDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    StaticLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::StructDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    StructLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::EnumDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    EnumLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::UnionDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    UnionLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::TraitDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    TraitLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::ImplBlock(_)
+                | ast::ModuleItem::UseItem(_)
+                | ast::ModuleItem::ExternCrateItem(_)
+                | ast::ModuleItem::Module(_) => continue,
+            };
+            self.body.defs.push(def)
+        }
+    }
    fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
        if let Some(block) = expr {
            self.collect_block(block)
diff --git a/crates/ra_hir_def/src/child_by_source.rs b/crates/ra_hir_def/src/child_by_source.rs
index 3c9379b15..f5a65ad40 100644
--- a/crates/ra_hir_def/src/child_by_source.rs
+++ b/crates/ra_hir_def/src/child_by_source.rs
@@ -11,8 +11,8 @@ use crate::{
    dyn_map::DynMap,
    keys,
    src::{HasChildSource, HasSource},
-    AdtId, AssocItemId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId, ModuleId,
+    AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId,
-    StructFieldId, TraitId, VariantId,
+    ModuleId, StructFieldId, TraitId, VariantId,
 };
 pub trait ChildBySource {
@@ -76,47 +76,11 @@ impl ChildBySource for ModuleId {
        let mut res = DynMap::default();
        let crate_def_map = db.crate_def_map(self.krate);
-        for item in crate_def_map[self.local_id].scope.declarations() {
+        let module_data = &crate_def_map[self.local_id];
-            match item {
-                ModuleDefId::FunctionId(func) => {
-                    let src = func.lookup(db).source(db);
-                    res[keys::FUNCTION].insert(src, func)
-                }
-                ModuleDefId::ConstId(konst) => {
-                    let src = konst.lookup(db).source(db);
-                    res[keys::CONST].insert(src, konst)
-                }
-                ModuleDefId::StaticId(statik) => {
-                    let src = statik.lookup(db).source(db);
-                    res[keys::STATIC].insert(src, statik)
-                }
-                ModuleDefId::TypeAliasId(ty) => {
-                    let src = ty.lookup(db).source(db);
-                    res[keys::TYPE_ALIAS].insert(src, ty)
-                }
-                ModuleDefId::TraitId(trait_) => {
-                    let src = trait_.lookup(db).source(db);
-                    res[keys::TRAIT].insert(src, trait_)
-                }
-                ModuleDefId::AdtId(adt) => match adt {
-                    AdtId::StructId(strukt) => {
-                        let src = strukt.lookup(db).source(db);
-                        res[keys::STRUCT].insert(src, strukt)
-                    }
-                    AdtId::UnionId(union_) => {
-                        let src = union_.lookup(db).source(db);
-                        res[keys::UNION].insert(src, union_)
-                    }
-                    AdtId::EnumId(enum_) => {
-                        let src = enum_.lookup(db).source(db);
-                        res[keys::ENUM].insert(src, enum_)
-                    }
-                },
-                _ => (),
-            }
-        }
-        for &impl_ in crate_def_map[self.local_id].impls.iter() {
+        module_data.scope.declarations().for_each(|item| add_module_def(db, &mut res, item));
+        for &impl_ in module_data.impls.iter() {
            let src = impl_.lookup(db).source(db);
            res[keys::IMPL].insert(src, impl_)
        }
@@ -125,6 +89,46 @@ impl ChildBySource for ModuleId {
    }
 }
+fn add_module_def(db: &impl DefDatabase, map: &mut DynMap, item: ModuleDefId) {
+    match item {
+        ModuleDefId::FunctionId(func) => {
+            let src = func.lookup(db).source(db);
+            map[keys::FUNCTION].insert(src, func)
+        }
+        ModuleDefId::ConstId(konst) => {
+            let src = konst.lookup(db).source(db);
+            map[keys::CONST].insert(src, konst)
+        }
+        ModuleDefId::StaticId(statik) => {
+            let src = statik.lookup(db).source(db);
+            map[keys::STATIC].insert(src, statik)
+        }
+        ModuleDefId::TypeAliasId(ty) => {
+            let src = ty.lookup(db).source(db);
+            map[keys::TYPE_ALIAS].insert(src, ty)
+        }
+        ModuleDefId::TraitId(trait_) => {
+            let src = trait_.lookup(db).source(db);
+            map[keys::TRAIT].insert(src, trait_)
+        }
+        ModuleDefId::AdtId(adt) => match adt {
+            AdtId::StructId(strukt) => {
+                let src = strukt.lookup(db).source(db);
+                map[keys::STRUCT].insert(src, strukt)
+            }
+            AdtId::UnionId(union_) => {
+                let src = union_.lookup(db).source(db);
+                map[keys::UNION].insert(src, union_)
+            }
+            AdtId::EnumId(enum_) => {
+                let src = enum_.lookup(db).source(db);
+                map[keys::ENUM].insert(src, enum_)
+            }
+        },
+        _ => (),
+    }
+}
 impl ChildBySource for VariantId {
    fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
        let mut res = DynMap::default();
@@ -160,3 +164,12 @@ impl ChildBySource for EnumId {
        res
    }
 }
+impl ChildBySource for DefWithBodyId {
+    fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+        let body = db.body(*self);
+        body.defs.iter().copied().for_each(|item| add_module_def(db, &mut res, item));
+        res
+    }
+}
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 4f4ef57cc..14e86936b 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -12,8 +12,8 @@ use crate::{
    db::DefDatabase,
    src::HasSource,
    type_ref::{Mutability, TypeRef},
-    AssocItemId, ConstId, ConstLoc, ContainerId, FunctionId, FunctionLoc, ImplId, Intern, Lookup,
+    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, ImplId, Intern,
-    StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -99,7 +99,7 @@ impl TraitData {
        let auto = src.value.is_auto();
        let ast_id_map = db.ast_id_map(src.file_id);
-        let container = ContainerId::TraitId(tr);
+        let container = AssocContainerId::TraitId(tr);
        let items = if let Some(item_list) = src.value.item_list() {
            item_list
                .impl_items()
@@ -180,7 +180,7 @@ impl ImplData {
                .map(|item_node| match item_node {
                    ast::ImplItem::FnDef(it) => {
                        let def = FunctionLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
@@ -188,7 +188,7 @@ impl ImplData {
                    }
                    ast::ImplItem::ConstDef(it) => {
                        let def = ConstLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
@@ -196,7 +196,7 @@ impl ImplData {
                    }
                    ast::ImplItem::TypeAliasDef(it) => {
                        let def = TypeAliasLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index f085bbe87..8ed1599ff 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -45,7 +45,7 @@ use std::hash::Hash;
 use hir_expand::{ast_id_map::FileAstId, AstId, HirFileId, InFile, MacroDefId};
 use ra_arena::{impl_arena_id, RawId};
 use ra_db::{impl_intern_key, salsa, CrateId};
-use ra_syntax::ast;
+use ra_syntax::{ast, AstNode};
 use crate::builtin_type::BuiltinType;
@@ -65,101 +65,57 @@ pub struct ModuleId {
 pub struct LocalModuleId(RawId);
 impl_arena_id!(LocalModuleId);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct FunctionId(salsa::InternId);
-impl_intern_key!(FunctionId);
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FunctionLoc {
+pub struct ItemLoc<N: AstNode> {
    pub container: ContainerId,
-    pub ast_id: AstId<ast::FnDef>,
+    pub ast_id: AstId<N>,
 }
-impl Intern for FunctionLoc {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-    type ID = FunctionId;
+pub struct AssocItemLoc<N: AstNode> {
-    fn intern(self, db: &impl db::DefDatabase) -> FunctionId {
+    pub container: AssocContainerId,
-        db.intern_function(self)
+    pub ast_id: AstId<N>,
-    }
 }
-impl Lookup for FunctionId {
+macro_rules! impl_intern {
-    type Data = FunctionLoc;
+    ($id:ident, $loc:ident, $intern:ident, $lookup:ident) => {
-    fn lookup(&self, db: &impl db::DefDatabase) -> FunctionLoc {
+        impl_intern_key!($id);
-        db.lookup_intern_function(*self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        impl Intern for $loc {
-pub struct StructId(salsa::InternId);
+            type ID = $id;
-impl_intern_key!(StructId);
+            fn intern(self, db: &impl db::DefDatabase) -> $id {
+                db.$intern(self)
+            }
+        }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+        impl Lookup for $id {
-pub struct StructLoc {
+            type Data = $loc;
-    pub container: ModuleId,
+            fn lookup(&self, db: &impl db::DefDatabase) -> $loc {
-    pub ast_id: AstId<ast::StructDef>,
+                db.$lookup(*self)
+            }
+        }
+    };
 }
-impl Intern for StructLoc {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type ID = StructId;
+pub struct FunctionId(salsa::InternId);
-    fn intern(self, db: &impl db::DefDatabase) -> StructId {
+type FunctionLoc = AssocItemLoc<ast::FnDef>;
-        db.intern_struct(self)
+impl_intern!(FunctionId, FunctionLoc, intern_function, lookup_intern_function);
-    }
-}
-impl Lookup for StructId {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type Data = StructLoc;
+pub struct StructId(salsa::InternId);
-    fn lookup(&self, db: &impl db::DefDatabase) -> StructLoc {
+type StructLoc = ItemLoc<ast::StructDef>;
-        db.lookup_intern_struct(*self)
+impl_intern!(StructId, StructLoc, intern_struct, lookup_intern_struct);
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct UnionId(salsa::InternId);
-impl_intern_key!(UnionId);
+pub type UnionLoc = ItemLoc<ast::UnionDef>;
+impl_intern!(UnionId, UnionLoc, intern_union, lookup_intern_union);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnionLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::UnionDef>,
-}
-impl Intern for UnionLoc {
-    type ID = UnionId;
-    fn intern(self, db: &impl db::DefDatabase) -> UnionId {
-        db.intern_union(self)
-    }
-}
-impl Lookup for UnionId {
-    type Data = UnionLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> UnionLoc {
-        db.lookup_intern_union(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EnumId(salsa::InternId);
-impl_intern_key!(EnumId);
+pub type EnumLoc = ItemLoc<ast::EnumDef>;
+impl_intern!(EnumId, EnumLoc, intern_enum, lookup_intern_enum);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::EnumDef>,
-}
-impl Intern for EnumLoc {
-    type ID = EnumId;
-    fn intern(self, db: &impl db::DefDatabase) -> EnumId {
-        db.intern_enum(self)
-    }
-}
-impl Lookup for EnumId {
-    type Data = EnumLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> EnumLoc {
-        db.lookup_intern_enum(*self)
-    }
-}
 // FIXME: rename to `VariantId`, only enums can ave variants
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -184,122 +140,38 @@ impl_arena_id!(LocalStructFieldId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);
-impl_intern_key!(ConstId);
+type ConstLoc = AssocItemLoc<ast::ConstDef>;
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+impl_intern!(ConstId, ConstLoc, intern_const, lookup_intern_const);
-pub struct ConstLoc {
-    pub container: ContainerId,
-    pub ast_id: AstId<ast::ConstDef>,
-}
-impl Intern for ConstLoc {
-    type ID = ConstId;
-    fn intern(self, db: &impl db::DefDatabase) -> ConstId {
-        db.intern_const(self)
-    }
-}
-impl Lookup for ConstId {
-    type Data = ConstLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> ConstLoc {
-        db.lookup_intern_const(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StaticId(salsa::InternId);
-impl_intern_key!(StaticId);
+pub type StaticLoc = ItemLoc<ast::StaticDef>;
+impl_intern!(StaticId, StaticLoc, intern_static, lookup_intern_static);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StaticLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::StaticDef>,
-}
-impl Intern for StaticLoc {
-    type ID = StaticId;
-    fn intern(self, db: &impl db::DefDatabase) -> StaticId {
-        db.intern_static(self)
-    }
-}
-impl Lookup for StaticId {
-    type Data = StaticLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> StaticLoc {
-        db.lookup_intern_static(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TraitId(salsa::InternId);
-impl_intern_key!(TraitId);
+pub type TraitLoc = ItemLoc<ast::TraitDef>;
+impl_intern!(TraitId, TraitLoc, intern_trait, lookup_intern_trait);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::TraitDef>,
-}
-impl Intern for TraitLoc {
-    type ID = TraitId;
-    fn intern(self, db: &impl db::DefDatabase) -> TraitId {
-        db.intern_trait(self)
-    }
-}
-impl Lookup for TraitId {
-    type Data = TraitLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> TraitLoc {
-        db.lookup_intern_trait(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeAliasId(salsa::InternId);
-impl_intern_key!(TypeAliasId);
+type TypeAliasLoc = AssocItemLoc<ast::TypeAliasDef>;
+impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeAliasLoc {
-    pub container: ContainerId,
-    pub ast_id: AstId<ast::TypeAliasDef>,
-}
-impl Intern for TypeAliasLoc {
-    type ID = TypeAliasId;
-    fn intern(self, db: &impl db::DefDatabase) -> TypeAliasId {
-        db.intern_type_alias(self)
-    }
-}
-impl Lookup for TypeAliasId {
-    type Data = TypeAliasLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> TypeAliasLoc {
-        db.lookup_intern_type_alias(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ImplId(salsa::InternId);
-impl_intern_key!(ImplId);
+type ImplLoc = ItemLoc<ast::ImplBlock>;
+impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::ImplBlock>,
-}
-impl Intern for ImplLoc {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type ID = ImplId;
+pub struct TypeParamId {
-    fn intern(self, db: &impl db::DefDatabase) -> ImplId {
+    pub parent: GenericDefId,
-        db.intern_impl(self)
+    pub local_id: LocalTypeParamId,
-    }
 }
-impl Lookup for ImplId {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type Data = ImplLoc;
+pub struct LocalTypeParamId(RawId);
-    fn lookup(&self, db: &impl db::DefDatabase) -> ImplLoc {
+impl_arena_id!(LocalTypeParamId);
-        db.lookup_intern_impl(*self)
-    }
-}
 macro_rules! impl_froms {
    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
@@ -321,21 +193,18 @@ macro_rules! impl_froms {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TypeParamId {
+pub enum ContainerId {
-    pub parent: GenericDefId,
+    ModuleId(ModuleId),
-    pub local_id: LocalTypeParamId,
+    DefWithBodyId(DefWithBodyId),
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LocalTypeParamId(RawId);
+pub enum AssocContainerId {
-impl_arena_id!(LocalTypeParamId);
+    ContainerId(ContainerId),
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ContainerId {
-    ModuleId(ModuleId),
    ImplId(ImplId),
    TraitId(TraitId),
 }
+impl_froms!(AssocContainerId: ContainerId);
 /// A Data Type
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -478,33 +347,28 @@ pub trait HasModule {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId;
 }
-impl HasModule for FunctionLoc {
+impl HasModule for ContainerId {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        match *self {
            ContainerId::ModuleId(it) => it,
-            ContainerId::ImplId(it) => it.lookup(db).container,
+            ContainerId::DefWithBodyId(it) => it.module(db),
-            ContainerId::TraitId(it) => it.lookup(db).container,
        }
    }
 }
-impl HasModule for TypeAliasLoc {
+impl HasModule for AssocContainerId {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        match *self {
-            ContainerId::ModuleId(it) => it,
+            AssocContainerId::ContainerId(it) => it.module(db),
-            ContainerId::ImplId(it) => it.lookup(db).container,
+            AssocContainerId::ImplId(it) => it.lookup(db).container.module(db),
-            ContainerId::TraitId(it) => it.lookup(db).container,
+            AssocContainerId::TraitId(it) => it.lookup(db).container.module(db),
        }
    }
 }
-impl HasModule for ConstLoc {
+impl<N: AstNode> HasModule for AssocItemLoc<N> {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        self.container.module(db)
-            ContainerId::ModuleId(it) => it,
-            ContainerId::ImplId(it) => it.lookup(db).container,
-            ContainerId::TraitId(it) => it.lookup(db).container,
-        }
    }
 }
@@ -515,6 +379,7 @@ impl HasModule for AdtId {
            AdtId::UnionId(it) => it.lookup(db).container,
            AdtId::EnumId(it) => it.lookup(db).container,
        }
+        .module(db)
    }
 }
@@ -533,17 +398,17 @@ impl HasModule for GenericDefId {
        match self {
            GenericDefId::FunctionId(it) => it.lookup(db).module(db),
            GenericDefId::AdtId(it) => it.module(db),
-            GenericDefId::TraitId(it) => it.lookup(db).container,
+            GenericDefId::TraitId(it) => it.lookup(db).container.module(db),
            GenericDefId::TypeAliasId(it) => it.lookup(db).module(db),
-            GenericDefId::ImplId(it) => it.lookup(db).container,
+            GenericDefId::ImplId(it) => it.lookup(db).container.module(db),
-            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container,
+            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
            GenericDefId::ConstId(it) => it.lookup(db).module(db),
        }
    }
 }
 impl HasModule for StaticLoc {
-    fn module(&self, _db: &impl db::DefDatabase) -> ModuleId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        self.container
+        self.container.module(db)
    }
 }
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
index 65239ca0a..457ba4abe 100644
--- a/crates/ra_hir_def/src/marks.rs
+++ b/crates/ra_hir_def/src/marks.rs
@@ -5,6 +5,7 @@ test_utils::marks!(
    name_res_works_for_broken_modules
    can_import_enum_variant
    glob_enum
+    glob_enum_group
    glob_across_crates
    std_prelude
    macro_rules_from_other_crates_are_visible_with_macro_use
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 9aae7e48e..af52fa36e 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -57,9 +57,7 @@ mod tests;
 use std::sync::Arc;
-use hir_expand::{
+use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId};
-    ast_id_map::FileAstId, diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId,
-};
 use once_cell::sync::Lazy;
 use ra_arena::Arena;
 use ra_db::{CrateId, Edition, FileId, FilePosition};
@@ -76,7 +74,7 @@ use crate::{
    nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
    path::ModPath,
    per_ns::PerNs,
-    AstId, FunctionId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
+    AstId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
 };
 /// Contains all top-level defs from a macro-expanded crate
@@ -176,11 +174,6 @@ pub struct ModuleData {
    pub impls: Vec<ImplId>,
 }
-#[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct Declarations {
-    fns: FxHashMap<FileAstId<ast::FnDef>, FunctionId>,
-}
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ModuleScope {
    items: FxHashMap<Name, Resolution>,
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 8bbf7ffa2..e68bf4868 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -661,9 +661,10 @@ where
                            krate: self.def_collector.def_map.krate,
                            local_id: self.module_id,
                        };
+                        let container = ContainerId::ModuleId(module);
                        let ast_id = self.raw_items[imp].ast_id;
                        let impl_id =
-                            ImplLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                            ImplLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                                .intern(self.def_collector.db);
                        self.def_collector.def_map.modules[self.module_id].impls.push(impl_id)
                    }
@@ -760,10 +761,11 @@ where
        self.collect_derives(attrs, def);
        let name = def.name.clone();
+        let container = ContainerId::ModuleId(module);
        let def: PerNs = match def.kind {
            raw::DefKind::Function(ast_id) => {
                let def = FunctionLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
@@ -771,23 +773,23 @@ where
                PerNs::values(def.into())
            }
            raw::DefKind::Struct(ast_id) => {
-                let def = StructLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = StructLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::both(def.into(), def.into())
            }
            raw::DefKind::Union(ast_id) => {
-                let def = UnionLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = UnionLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::both(def.into(), def.into())
            }
            raw::DefKind::Enum(ast_id) => {
-                let def = EnumLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = EnumLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::types(def.into())
            }
            raw::DefKind::Const(ast_id) => {
                let def = ConstLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
@@ -795,20 +797,20 @@ where
                PerNs::values(def.into())
            }
            raw::DefKind::Static(ast_id) => {
-                let def = StaticLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = StaticLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::values(def.into())
            }
            raw::DefKind::Trait(ast_id) => {
-                let def = TraitLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = TraitLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::types(def.into())
            }
            raw::DefKind::TypeAlias(ast_id) => {
                let def = TypeAliasLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 1dbc4f371..2dd779b66 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -145,11 +145,6 @@ impl CrateDefMap {
                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
                }
            }
-            PathKind::Type(_) => {
-                // This is handled in `infer::infer_path_expr`
-                // The result returned here does not matter
-                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
-            }
        };
        for (i, segment) in segments {
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 5b03fe365..5e24cb94d 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -112,3 +112,24 @@ fn glob_enum() {
    "###
    );
 }
+#[test]
+fn glob_enum_group() {
+    covers!(glob_enum_group);
+    let map = def_map(
+        "
+        //- /lib.rs
+        enum Foo {
+            Bar, Baz
+        }
+        use self::Foo::{*};
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Baz: t v
+   ⋮Foo: t
+    "###
+    );
+}
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 9e37ac416..00325cd99 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -18,6 +18,18 @@ pub struct ModPath {
    pub segments: Vec<Name>,
 }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PathKind {
+    Plain,
+    /// `self::` is `Super(0)`
+    Super(u8),
+    Crate,
+    /// Absolute path (::foo)
+    Abs,
+    /// `$crate` from macro expansion
+    DollarCrate(CrateId),
+}
 impl ModPath {
    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
        lower::lower_path(path, hygiene).map(|it| it.mod_path)
@@ -70,6 +82,9 @@ impl ModPath {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
+    /// Type based path like `<T>::foo`.
+    /// Note that paths like `<Type as Trait>::foo` are desugard to `Trait::<Self=Type>::foo`.
+    type_anchor: Option<Box<TypeRef>>,
    mod_path: ModPath,
    /// Invariant: the same len as self.path.segments
    generic_args: Vec<Option<Arc<GenericArgs>>>,
@@ -97,19 +112,6 @@ pub enum GenericArg {
    // or lifetime...
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PathKind {
-    Plain,
-    Super(u8),
-    Crate,
-    // Absolute path
-    Abs,
-    // Type based path like `<T>::foo`
-    Type(Box<TypeRef>),
-    // `$crate` from macro expansion
-    DollarCrate(CrateId),
-}
 impl Path {
    /// Converts an `ast::Path` to `Path`. Works with use trees.
    /// DEPRECATED: It does not handle `$crate` from macro call.
@@ -125,18 +127,17 @@ impl Path {
    /// Converts an `ast::NameRef` into a single-identifier `Path`.
    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> Path {
-        Path { mod_path: name_ref.as_name().into(), generic_args: vec![None] }
+        Path { type_anchor: None, mod_path: name_ref.as_name().into(), generic_args: vec![None] }
-    }
-    /// `true` if this path is just a standalone `self`
-    pub fn is_self(&self) -> bool {
-        self.mod_path.is_self()
    }
    pub fn kind(&self) -> &PathKind {
        &self.mod_path.kind
    }
+    pub fn type_anchor(&self) -> Option<&TypeRef> {
+        self.type_anchor.as_ref().map(|it| &**it)
+    }
    pub fn segments(&self) -> PathSegments<'_> {
        PathSegments {
            segments: self.mod_path.segments.as_slice(),
@@ -153,6 +154,7 @@ impl Path {
            return None;
        }
        let res = Path {
+            type_anchor: self.type_anchor.clone(),
            mod_path: ModPath {
                kind: self.mod_path.kind.clone(),
                segments: self.mod_path.segments[..self.mod_path.segments.len() - 1].to_vec(),
@@ -225,6 +227,7 @@ impl GenericArgs {
 impl From<Name> for Path {
    fn from(name: Name) -> Path {
        Path {
+            type_anchor: None,
            mod_path: ModPath::from_simple_segments(PathKind::Plain, iter::once(name)),
            generic_args: vec![None],
        }
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index c71b52d89..62aafd508 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -22,6 +22,7 @@ pub(super) use lower_use::lower_use_tree;
 /// It correctly handles `$crate` based path from macro call.
 pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
    let mut kind = PathKind::Plain;
+    let mut type_anchor = None;
    let mut segments = Vec::new();
    let mut generic_args = Vec::new();
    loop {
@@ -63,7 +64,8 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                match trait_ref {
                    // <T>::foo
                    None => {
-                        kind = PathKind::Type(Box::new(self_type));
+                        type_anchor = Some(Box::new(self_type));
+                        kind = PathKind::Plain;
                    }
                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                    Some(trait_ref) => {
@@ -111,7 +113,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    segments.reverse();
    generic_args.reverse();
    let mod_path = ModPath { kind, segments };
-    return Some(Path { mod_path, generic_args });
+    return Some(Path { type_anchor, mod_path, generic_args });
    fn qualifier(path: &ast::Path) -> Option<ast::Path> {
        if let Some(q) = path.qualifier() {
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 062c02063..3218eaf0a 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -9,6 +9,7 @@ use hir_expand::{
    name::{AsName, Name},
 };
 use ra_syntax::ast::{self, NameOwner};
+use test_utils::tested_by;
 use crate::path::{ModPath, PathKind};
@@ -34,6 +35,7 @@ pub(crate) fn lower_use_tree(
        }
    } else {
        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
+        let is_glob = tree.has_star();
        if let Some(ast_path) = tree.path() {
            // Handle self in a path.
            // E.g. `use something::{self, <...>}`
@@ -48,11 +50,15 @@ pub(crate) fn lower_use_tree(
                }
            }
            if let Some(path) = convert_path(prefix, ast_path, hygiene) {
-                let is_glob = tree.has_star();
                cb(path, &tree, is_glob, alias)
            }
-            // FIXME: report errors somewhere
+        // FIXME: report errors somewhere
-            // We get here if we do
+        // We get here if we do
+        } else if is_glob {
+            tested_by!(glob_enum_group);
+            if let Some(prefix) = prefix {
+                cb(prefix, &tree, is_glob, None)
+            }
        }
    }
 }
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 2694c0438..af9d194f8 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -17,9 +17,9 @@ use crate::{
    nameres::{BuiltinShadowMode, CrateDefMap},
    path::{ModPath, PathKind},
    per_ns::PerNs,
-    AdtId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
+    AdtId, AssocContainerId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId,
-    HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId,
+    FunctionId, GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
-    TypeAliasId, TypeParamId, VariantId,
+    StaticId, StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
 };
 #[derive(Debug, Clone, Default)]
@@ -583,9 +583,18 @@ impl HasResolver for DefWithBodyId {
 impl HasResolver for ContainerId {
    fn resolver(self, db: &impl DefDatabase) -> Resolver {
        match self {
-            ContainerId::TraitId(it) => it.resolver(db),
-            ContainerId::ImplId(it) => it.resolver(db),
            ContainerId::ModuleId(it) => it.resolver(db),
+            ContainerId::DefWithBodyId(it) => it.resolver(db),
+        }
+    }
+}
+impl HasResolver for AssocContainerId {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
+        match self {
+            AssocContainerId::ContainerId(it) => it.resolver(db),
+            AssocContainerId::TraitId(it) => it.resolver(db),
+            AssocContainerId::ImplId(it) => it.resolver(db),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/src.rs b/crates/ra_hir_def/src/src.rs
index 20200d1db..499375b80 100644
--- a/crates/ra_hir_def/src/src.rs
+++ b/crates/ra_hir_def/src/src.rs
@@ -2,94 +2,28 @@
 use hir_expand::InFile;
 use ra_arena::map::ArenaMap;
-use ra_syntax::ast;
+use ra_syntax::AstNode;
-use crate::{
+use crate::{db::DefDatabase, AssocItemLoc, ItemLoc};
-    db::DefDatabase, ConstLoc, EnumLoc, FunctionLoc, ImplLoc, StaticLoc, StructLoc, TraitLoc,
-    TypeAliasLoc, UnionLoc,
-};
 pub trait HasSource {
    type Value;
    fn source(&self, db: &impl DefDatabase) -> InFile<Self::Value>;
 }
-impl HasSource for FunctionLoc {
+impl<N: AstNode> HasSource for AssocItemLoc<N> {
-    type Value = ast::FnDef;
+    type Value = N;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::FnDef> {
+    fn source(&self, db: &impl DefDatabase) -> InFile<N> {
        let node = self.ast_id.to_node(db);
        InFile::new(self.ast_id.file_id, node)
    }
 }
-impl HasSource for TypeAliasLoc {
+impl<N: AstNode> HasSource for ItemLoc<N> {
-    type Value = ast::TypeAliasDef;
+    type Value = N;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::TypeAliasDef> {
+    fn source(&self, db: &impl DefDatabase) -> InFile<N> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for ConstLoc {
-    type Value = ast::ConstDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::ConstDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for StaticLoc {
-    type Value = ast::StaticDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::StaticDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for ImplLoc {
-    type Value = ast::ImplBlock;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::ImplBlock> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for TraitLoc {
-    type Value = ast::TraitDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::TraitDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for StructLoc {
-    type Value = ast::StructDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::StructDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for UnionLoc {
-    type Value = ast::UnionDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::UnionDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for EnumLoc {
-    type Value = ast::EnumDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::EnumDef> {
        let node = self.ast_id.to_node(db);
        InFile::new(self.ast_id.file_id, node)
    }