3 files changed, 70 insertions, 38 deletions

diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index 4a19842c4..f3a346152 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -4,9 +4,10 @@ use ra_syntax::{
     ast::{self, NameOwner},
     SmolStr,
 };
-use relative_path::RelativePathBuf;
+use relative_path::{RelativePathBuf, RelativePath};
 use rustc_hash::{FxHashMap, FxHashSet};
-use ra_db::{SourceRoot, SourceRootId, FileResolverImp, Cancelable, FileId,};
+use arrayvec::ArrayVec;
+use ra_db::{SourceRoot, SourceRootId, Cancelable, FileId};
 
 use crate::{
     HirDatabase,
@@ -65,7 +66,7 @@ fn create_module_tree<'a>(
     let mut visited = FxHashSet::default();
 
     let source_root = db.source_root(source_root);
-    for &file_id in source_root.files.iter() {
+    for &file_id in source_root.files.values() {
         let source = ModuleSource::new_file(file_id);
         if visited.contains(&source) {
             continue; // TODO: use explicit crate_roots here
@@ -110,8 +111,7 @@ fn build_subtree(
 
         let (points_to, problem) = match sub {
             Submodule::Declaration(name) => {
-                let (points_to, problem) =
-                    resolve_submodule(source, &name, &source_root.file_resolver);
+                let (points_to, problem) = resolve_submodule(db, source, &name);
                 let points_to = points_to
                     .into_iter()
                     .map(|file_id| match roots.remove(&file_id) {
@@ -153,34 +153,42 @@ fn build_subtree(
 }
 
 fn resolve_submodule(
+    db: &impl HirDatabase,
     source: ModuleSource,
     name: &SmolStr,
-    file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
-    // TODO: handle submodules of inline modules properly
+    // FIXME: handle submodules of inline modules properly
     let file_id = source.file_id();
-    let mod_name = file_resolver.file_stem(file_id);
+    let source_root_id = db.file_source_root(file_id);
+    let path = db.file_relative_path(file_id);
+    let root = RelativePathBuf::default();
+    let dir_path = path.parent().unwrap_or(&root);
+    let mod_name = path.file_stem().unwrap_or("unknown");
     let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
 
-    let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
-    let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
-    let file_dir_mod = RelativePathBuf::from(format!("../{}/{}.rs", mod_name, name));
-    let tmp1;
-    let tmp2;
-    let candidates = if is_dir_owner {
-        tmp1 = [&file_mod, &dir_mod];
-        tmp1.iter()
+    let file_mod = dir_path.join(format!("{}.rs", name));
+    let dir_mod = dir_path.join(format!("{}/mod.rs", name));
+    let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name));
+    let mut candidates = ArrayVec::<[_; 2]>::new();
+    if is_dir_owner {
+        candidates.push(file_mod.clone());
+        candidates.push(dir_mod);
     } else {
-        tmp2 = [&file_dir_mod];
-        tmp2.iter()
+        candidates.push(file_dir_mod.clone());
     };
-
+    let sr = db.source_root(source_root_id);
     let points_to = candidates
-        .filter_map(|path| file_resolver.resolve(file_id, path))
+        .into_iter()
+        .filter_map(|path| sr.files.get(&path))
+        .map(|&it| it)
         .collect::<Vec<_>>();
     let problem = if points_to.is_empty() {
         Some(Problem::UnresolvedModule {
-            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
+            candidate: RelativePath::new("../").join(&if is_dir_owner {
+                file_mod
+            } else {
+                file_dir_mod
+            }),
         })
     } else {
         None
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 5540b827f..f44abc730 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -32,11 +32,12 @@ use crate::{
     SourceItemId, SourceFileItemId, SourceFileItems,
     Path, PathKind,
     HirDatabase, Crate,
-    module::{ModuleId, ModuleTree},
+    module::{Module, ModuleId, ModuleTree},
 };
 
 /// Item map is the result of the name resolution. Item map contains, for each
 /// module, the set of visible items.
+// FIXME: currenty we compute item map per source-root. We should do it per crate instead.
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ItemMap {
     pub per_module: FxHashMap<ModuleId, ModuleScope>,
@@ -252,7 +253,8 @@ where
                 let krate = Crate::new(crate_id);
                 for dep in krate.dependencies(self.db) {
                     if let Some(module) = dep.krate.root_module(self.db)? {
-                        self.add_module_item(&mut module_items, dep.name, module.module_id);
+                        let def_id = module.def_id(self.db);
+                        self.add_module_item(&mut module_items, dep.name, def_id);
                     }
                 }
             };
@@ -294,21 +296,21 @@ where
 
         // Populate modules
         for (name, module_id) in module_id.children(&self.module_tree) {
-            self.add_module_item(&mut module_items, name, module_id);
+            let def_loc = DefLoc {
+                kind: DefKind::Module,
+                source_root_id: self.source_root,
+                module_id,
+                source_item_id: module_id.source(&self.module_tree).0,
+            };
+            let def_id = def_loc.id(self.db);
+            self.add_module_item(&mut module_items, name, def_id);
         }
 
         self.result.per_module.insert(module_id, module_items);
         Ok(())
     }
 
-    fn add_module_item(&self, module_items: &mut ModuleScope, name: SmolStr, module_id: ModuleId) {
-        let def_loc = DefLoc {
-            kind: DefKind::Module,
-            source_root_id: self.source_root,
-            module_id,
-            source_item_id: module_id.source(&self.module_tree).0,
-        };
-        let def_id = def_loc.id(self.db);
+    fn add_module_item(&self, module_items: &mut ModuleScope, name: SmolStr, def_id: DefId) {
         let resolution = Resolution {
             def_id: Some(def_id),
             import: None,
@@ -329,7 +331,7 @@ where
             ImportKind::Named(ptr) => ptr,
         };
 
-        let mut curr = match import.path.kind {
+        let mut curr: ModuleId = match import.path.kind {
             PathKind::Plain | PathKind::Self_ => module_id,
             PathKind::Super => {
                 match module_id.parent(&self.module_tree) {
@@ -356,9 +358,30 @@ where
                 curr = match def_id.loc(self.db) {
                     DefLoc {
                         kind: DefKind::Module,
-                        module_id,
+                        module_id: target_module_id,
+                        source_root_id,
                         ..
-                    } => module_id,
+                    } => {
+                        if source_root_id == self.source_root {
+                            target_module_id
+                        } else {
+                            let module = Module::new(self.db, source_root_id, target_module_id)?;
+                            let path = Path {
+                                segments: import.path.segments[i + 1..].iter().cloned().collect(),
+                                kind: PathKind::Crate,
+                            };
+                            if let Some(def_id) = module.resolve_path(self.db, path)? {
+                                self.update(module_id, |items| {
+                                    let res = Resolution {
+                                        def_id: Some(def_id),
+                                        import: Some(ptr),
+                                    };
+                                    items.items.insert(name.clone(), res);
+                                })
+                            }
+                            return Ok(());
+                        }
+                    }
                     _ => return Ok(()),
                 }
             } else {
diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/module/nameres/tests.rs
index 9ddc32dcd..9fa9146e3 100644
--- a/crates/ra_hir/src/module/nameres/tests.rs
+++ b/crates/ra_hir/src/module/nameres/tests.rs
@@ -3,6 +3,7 @@ use std::sync::Arc;
 use salsa::Database;
 use ra_db::{FilesDatabase, CrateGraph};
 use ra_syntax::SmolStr;
+use relative_path::RelativePath;
 
 use crate::{
     self as hir,
@@ -44,7 +45,7 @@ fn item_map_smoke_test() {
 
 #[test]
 fn item_map_across_crates() {
-    let (mut db, files) = MockDatabase::with_files(
+    let (mut db, sr) = MockDatabase::with_files(
         "
         //- /main.rs
         use test_crate::Baz;
@@ -53,8 +54,8 @@ fn item_map_across_crates() {
         pub struct Baz;
     ",
     );
-    let main_id = files.file_id("/main.rs");
-    let lib_id = files.file_id("/lib.rs");
+    let main_id = sr.files[RelativePath::new("/main.rs")];
+    let lib_id = sr.files[RelativePath::new("/lib.rs")];
 
     let mut crate_graph = CrateGraph::default();
     let main_crate = crate_graph.add_crate_root(main_id);