1 files changed, 48 insertions, 68 deletions

diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index b35188a21..f7411c5cf 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,7 +1,7 @@
 //! 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, nameres::ModuleSource, EnumVariantId,
+    GenericDefId, ModuleId, VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
@@ -23,35 +23,43 @@ pub trait FromSource: Sized {
 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 })
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::STRUCT]
+            .get(&src)
+            .copied()
+            .map(Struct::from)
     }
 }
 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 })
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::UNION]
+            .get(&src)
+            .copied()
+            .map(Union::from)
     }
 }
 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 })
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::ENUM]
+            .get(&src)
+            .copied()
+            .map(Enum::from)
     }
 }
 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 })
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::TRAIT]
+            .get(&src)
+            .copied()
+            .map(Trait::from)
     }
 }
 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]
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::FUNCTION]
             .get(&src)
             .copied()
             .map(Function::from)
@@ -61,7 +69,7 @@ impl FromSource for Function {
 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]
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::CONST]
             .get(&src)
             .copied()
             .map(Const::from)
@@ -70,7 +78,7 @@ impl FromSource for Const {
 impl FromSource for Static {
     type Ast = ast::StaticDef;
     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()))[keys::STATIC]
             .get(&src)
             .copied()
             .map(Static::from)
@@ -80,8 +88,7 @@ impl FromSource for Static {
 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]
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::TYPE_ALIAS]
             .get(&src)
             .copied()
             .map(TypeAlias::from)
@@ -107,10 +114,10 @@ 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> {
-        // XXX: use `.parent()` to avoid finding ourselves
-        let parent = src.value.syntax().parent()?;
-        let container = Container::find(db, src.with_value(parent).as_ref())?;
-        container.child_by_source(db)[keys::IMPL].get(&src).copied().map(ImplBlock::from)
+        analyze_container(db, src.as_ref().map(|it| it.syntax()))[keys::IMPL]
+            .get(&src)
+            .copied()
+            .map(ImplBlock::from)
     }
 }
 
@@ -247,57 +254,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))
-}
-
-enum Container {
-    Trait(Trait),
-    ImplBlock(ImplBlock),
-    Module(Module),
+fn analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> DynMap {
+    _analyze_container(db, src).unwrap_or_default()
 }
 
-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))
 }