scope-based resolve path

2 files changed, 47 insertions, 11 deletions

diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
index 6890d8b09..51bc84bf1 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -17,6 +17,7 @@ use crate::{
     descriptors::{Path, PathKind, DescriptorDatabase},
     input::SourceRootId,
     arena::{Arena, Id},
+    loc2id::DefLoc,
 };
 
 pub(crate) use self::nameres::ModuleScope;
@@ -76,6 +77,20 @@ impl ModuleDescriptor {
         Ok(res)
     }
 
+    fn new(
+        db: &impl DescriptorDatabase,
+        source_root_id: SourceRootId,
+        module_id: ModuleId,
+    ) -> Cancelable<ModuleDescriptor> {
+        let module_tree = db._module_tree(source_root_id)?;
+        let res = ModuleDescriptor {
+            tree: module_tree,
+            source_root_id,
+            module_id,
+        };
+        Ok(res)
+    }
+
     /// Returns `mod foo;` or `mod foo {}` node whihc declared this module.
     /// Returns `None` for the root module
     pub fn parent_link_source(
@@ -133,25 +148,37 @@ impl ModuleDescriptor {
         Ok(res)
     }
 
-    pub(crate) fn resolve_path(&self, db: &impl DescriptorDatabase, path: Path) -> Cancelable<Option<ModuleDescriptor>> {
-        let res = match self.do_resolve_path(path) {
-            None => return Ok(None),
-            Some(it) => it,
+    pub(crate) fn resolve_path(
+        &self,
+        db: &impl DescriptorDatabase,
+        path: Path,
+    ) -> Cancelable<Option<ModuleDescriptor>> {
+        macro_rules! ctry {
+            ($expr:expr) => {
+                match $expr {
+                    None => return Ok(None),
+                    Some(it) => it,
+                }
+            };
         };
-        Ok(Some(res))
-    }
 
-    fn do_resolve_path(&self, path: Path) -> Option<ModuleDescriptor> {
         let mut curr = match path.kind {
             PathKind::Crate => self.crate_root(),
             PathKind::Self_ | PathKind::Plain => self.clone(),
-            PathKind::Super => self.parent()?,
+            PathKind::Super => ctry!(self.parent()),
         };
+
         let segments = path.segments;
         for name in segments {
-            curr = curr.child(&name)?;
+            let scope = curr.scope(db)?;
+            let def_id = ctry!(ctry!(scope.get(&name)).def_id);
+            curr = match db.id_maps().def_loc(def_id) {
+                DefLoc::Module { id, source_root } => ModuleDescriptor::new(db, source_root, id)?,
+                _ => return Ok(None),
+            };
         }
-        Some(curr)
+
+        Ok(Some(curr))
     }
 
     pub fn problems(&self, db: &impl DescriptorDatabase) -> Vec<(SyntaxNode, Problem)> {
diff --git a/crates/ra_analysis/src/descriptors/module/nameres.rs b/crates/ra_analysis/src/descriptors/module/nameres.rs
index d347a69b0..d2964f67f 100644
--- a/crates/ra_analysis/src/descriptors/module/nameres.rs
+++ b/crates/ra_analysis/src/descriptors/module/nameres.rs
@@ -103,7 +103,16 @@ pub(crate) struct ItemMap {
 
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub(crate) struct ModuleScope {
-    pub(crate) items: FxHashMap<SmolStr, Resolution>,
+    items: FxHashMap<SmolStr, Resolution>,
+}
+
+impl ModuleScope {
+    pub(crate) fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
+        self.items.iter()
+    }
+    pub(crate) fn get(&self, name: &SmolStr) -> Option<&Resolution> {
+        self.items.get(name)
+    }
 }
 
 /// A set of items and imports declared inside a module, without relation to