3 files changed, 75 insertions, 133 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index c013ff99b..c705d1630 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -11,7 +11,7 @@ use hir_def::{
     per_ns::PerNs,
     resolver::HasResolver,
     type_ref::{Mutability, TypeRef},
-    AdtId, AstItemDef, ConstId, ContainerId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId,
+    AdtId, ConstId, ContainerId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId,
     LocalEnumVariantId, LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId,
     StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
 };
@@ -269,7 +269,7 @@ pub struct Struct {
 
 impl Struct {
     pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.module(db) }
+        Module { id: self.id.lookup(db).container }
     }
 
     pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
@@ -290,7 +290,7 @@ impl Struct {
     }
 
     pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.module(db).krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
     }
 
     fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
@@ -309,11 +309,11 @@ impl Union {
     }
 
     pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.module(db) }
+        Module { id: self.id.lookup(db).container }
     }
 
     pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.module(db).krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
     }
 
     pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
@@ -337,7 +337,7 @@ pub struct Enum {
 
 impl Enum {
     pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.module(db) }
+        Module { id: self.id.lookup(db).container }
     }
 
     pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
@@ -357,7 +357,7 @@ impl Enum {
     }
 
     pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.module(db).krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
     }
 }
 
@@ -577,7 +577,7 @@ pub struct Trait {
 
 impl Trait {
     pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.module(db) }
+        Module { id: self.id.lookup(db).container }
     }
 
     pub fn name(self, db: &impl DefDatabase) -> Name {
@@ -809,7 +809,10 @@ impl ImplBlock {
         let resolver = self.id.resolver(db);
         let environment = TraitEnvironment::lower(db, &resolver);
         let ty = Ty::from_hir(db, &resolver, &impl_data.target_type);
-        Type { krate: self.id.module(db).krate, ty: InEnvironment { value: ty, environment } }
+        Type {
+            krate: self.id.lookup(db).container.krate,
+            ty: InEnvironment { value: ty, environment },
+        }
     }
 
     pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
@@ -821,7 +824,7 @@ impl ImplBlock {
     }
 
     pub fn module(&self, db: &impl DefDatabase) -> Module {
-        self.id.module(db).into()
+        self.id.lookup(db).container.into()
     }
 
     pub fn krate(&self, db: &impl DefDatabase) -> Crate {
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 307f3d5bf..7abb4bd75 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,7 +1,8 @@
 //! FIXME: write short doc here
 use hir_def::{
-    child_by_source::ChildBySource, dyn_map::DynMap, keys, nameres::ModuleSource, AstItemDef,
-    EnumVariantId, GenericDefId, LocationCtx, ModuleId, VariantId,
+    child_by_source::ChildBySource, dyn_map::DynMap, keys, keys::Key, nameres::ModuleSource,
+    ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId, StaticId, StructId,
+    TraitId, TypeAliasId, UnionId, VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
@@ -20,74 +21,47 @@ pub trait FromSource: Sized {
     fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self>;
 }
 
-impl FromSource for Struct {
-    type Ast = ast::StructDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
-        Some(Struct { id })
-    }
-}
-impl FromSource for Union {
-    type Ast = ast::UnionDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
-        Some(Union { id })
-    }
-}
-impl FromSource for Enum {
-    type Ast = ast::EnumDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
-        Some(Enum { id })
-    }
-}
-impl FromSource for Trait {
-    type Ast = ast::TraitDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
-        Some(Trait { id })
-    }
-}
-impl FromSource for Function {
-    type Ast = ast::FnDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        Container::find(db, src.as_ref().map(|it| it.syntax()))?.child_by_source(db)[keys::FUNCTION]
-            .get(&src)
-            .copied()
-            .map(Function::from)
-    }
+pub trait FromSourceByContainer: Sized {
+    type Ast: AstNode + 'static;
+    type Id: Copy + 'static;
+    const KEY: Key<Self::Ast, Self::Id>;
 }
 
-impl FromSource for Const {
-    type Ast = ast::ConstDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        Container::find(db, src.as_ref().map(|it| it.syntax()))?.child_by_source(db)[keys::CONST]
-            .get(&src)
-            .copied()
-            .map(Const::from)
-    }
-}
-impl FromSource for Static {
-    type Ast = ast::StaticDef;
+impl<T: FromSourceByContainer> FromSource for T
+where
+    T: From<<T as FromSourceByContainer>::Id>,
+{
+    type Ast = <T as FromSourceByContainer>::Ast;
     fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        Container::find(db, src.as_ref().map(|it| it.syntax()))?.child_by_source(db)[keys::STATIC]
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[T::KEY]
             .get(&src)
             .copied()
-            .map(Static::from)
+            .map(Self::from)
     }
 }
 
-impl FromSource for TypeAlias {
-    type Ast = ast::TypeAliasDef;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        Container::find(db, src.as_ref().map(|it| it.syntax()))?.child_by_source(db)
-            [keys::TYPE_ALIAS]
-            .get(&src)
-            .copied()
-            .map(TypeAlias::from)
-    }
+macro_rules! from_source_by_container_impls {
+    ($(($hir:ident, $id:ident, $ast:path, $key:path)),* ,) => {$(
+        impl FromSourceByContainer for $hir {
+            type Ast = $ast;
+            type Id = $id;
+            const KEY: Key<Self::Ast, Self::Id> = $key;
+        }
+    )*}
 }
 
+from_source_by_container_impls![
+    (Struct, StructId, ast::StructDef, keys::STRUCT),
+    (Union, UnionId, ast::UnionDef, keys::UNION),
+    (Enum, EnumId, ast::EnumDef, keys::ENUM),
+    (Trait, TraitId, ast::TraitDef, keys::TRAIT),
+    (Function, FunctionId, ast::FnDef, keys::FUNCTION),
+    (Static, StaticId, ast::StaticDef, keys::STATIC),
+    (Const, ConstId, ast::ConstDef, keys::CONST),
+    (TypeAlias, TypeAliasId, ast::TypeAliasDef, keys::TYPE_ALIAS),
+    (ImplBlock, ImplId, ast::ImplBlock, keys::IMPL),
+];
+
 impl FromSource for MacroDef {
     type Ast = ast::MacroCall;
     fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
@@ -104,14 +78,6 @@ impl FromSource for MacroDef {
     }
 }
 
-impl FromSource for ImplBlock {
-    type Ast = ast::ImplBlock;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
-        Some(ImplBlock { id })
-    }
-}
-
 impl FromSource for EnumVariant {
     type Ast = ast::EnumVariant;
     fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
@@ -245,57 +211,30 @@ impl Module {
     }
 }
 
-fn from_source<N, DEF>(db: &(impl DefDatabase + AstDatabase), src: InFile<N>) -> Option<DEF>
-where
-    N: AstNode,
-    DEF: AstItemDef<N>,
-{
-    let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-    let module = Module::from_definition(db, InFile::new(src.file_id, module_src))?;
-    let ctx = LocationCtx::new(db, module.id, src.file_id);
-    let items = db.ast_id_map(src.file_id);
-    let item_id = items.ast_id(&src.value);
-    Some(DEF::from_ast_id(ctx, item_id))
+fn analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> DynMap {
+    _analyze_container(db, src).unwrap_or_default()
 }
 
-enum Container {
-    Trait(Trait),
-    ImplBlock(ImplBlock),
-    Module(Module),
-}
-
-impl Container {
-    fn find(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> Option<Container> {
-        // FIXME: this doesn't try to handle nested declarations
-        for container in src.value.ancestors() {
-            let res = match_ast! {
-                match container {
-                    ast::TraitDef(it) => {
-                        let c = Trait::from_source(db, src.with_value(it))?;
-                        Container::Trait(c)
-                    },
-                    ast::ImplBlock(it) => {
-                        let c = ImplBlock::from_source(db, src.with_value(it))?;
-                        Container::ImplBlock(c)
-                     },
-                    _ => { continue },
-                }
-            };
-            return Some(res);
-        }
-
-        let module_source = ModuleSource::from_child_node(db, src);
-        let c = Module::from_definition(db, src.with_value(module_source))?;
-        Some(Container::Module(c))
+fn _analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> Option<DynMap> {
+    // FIXME: this doesn't try to handle nested declarations
+    for container in src.value.ancestors().skip(1) {
+        let res = match_ast! {
+            match container {
+                ast::TraitDef(it) => {
+                    let c = Trait::from_source(db, src.with_value(it))?;
+                    c.id.child_by_source(db)
+                },
+                ast::ImplBlock(it) => {
+                    let c = ImplBlock::from_source(db, src.with_value(it))?;
+                    c.id.child_by_source(db)
+                 },
+                _ => { continue },
+            }
+        };
+        return Some(res);
     }
-}
 
-impl ChildBySource for Container {
-    fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
-        match self {
-            Container::Trait(it) => it.id.child_by_source(db),
-            Container::ImplBlock(it) => it.id.child_by_source(db),
-            Container::Module(it) => it.id.child_by_source(db),
-        }
-    }
+    let module_source = ModuleSource::from_child_node(db, src);
+    let c = Module::from_definition(db, src.with_value(module_source))?;
+    Some(c.id.child_by_source(db))
 }
diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs
index b09582f93..72afecf26 100644
--- a/crates/ra_hir/src/has_source.rs
+++ b/crates/ra_hir/src/has_source.rs
@@ -4,7 +4,7 @@ use either::Either;
 use hir_def::{
     nameres::ModuleSource,
     src::{HasChildSource, HasSource as _},
-    AstItemDef, Lookup, VariantId,
+    Lookup, VariantId,
 };
 use ra_syntax::ast;
 
@@ -51,19 +51,19 @@ impl HasSource for StructField {
 impl HasSource for Struct {
     type Ast = ast::StructDef;
     fn source(self, db: &impl DefDatabase) -> InFile<ast::StructDef> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
     }
 }
 impl HasSource for Union {
     type Ast = ast::UnionDef;
     fn source(self, db: &impl DefDatabase) -> InFile<ast::UnionDef> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
     }
 }
 impl HasSource for Enum {
     type Ast = ast::EnumDef;
     fn source(self, db: &impl DefDatabase) -> InFile<ast::EnumDef> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
     }
 }
 impl HasSource for EnumVariant {
@@ -93,7 +93,7 @@ impl HasSource for Static {
 impl HasSource for Trait {
     type Ast = ast::TraitDef;
     fn source(self, db: &impl DefDatabase) -> InFile<ast::TraitDef> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
     }
 }
 impl HasSource for TypeAlias {
@@ -114,7 +114,7 @@ impl HasSource for MacroDef {
 impl HasSource for ImplBlock {
     type Ast = ast::ImplBlock;
     fn source(self, db: &impl DefDatabase) -> InFile<ast::ImplBlock> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
     }
 }
 impl HasSource for Import {