5 files changed, 97 insertions, 58 deletions

diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 1b9e148b2..61650cee9 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -5,6 +5,7 @@ version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
 
 [dependencies]
+arrayvec = "0.4.9"
 log = "0.4.5"
 relative-path = "0.4.0"
 salsa = "0.8.0"
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index b7193c4f3..9423e6571 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -2,12 +2,14 @@ use std::sync::Arc;
 
 use parking_lot::Mutex;
 use salsa::{self, Database};
-use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE, CrateGraph};
+use ra_db::{LocationIntener, BaseDatabase, FilePosition, FileId, CrateGraph, SourceRoot, SourceRootId};
 use relative_path::RelativePathBuf;
 use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
 
 use crate::{db, DefId, DefLoc};
 
+const WORKSPACE: SourceRootId = SourceRootId(0);
+
 #[derive(Debug)]
 pub(crate) struct MockDatabase {
     events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
@@ -16,10 +18,10 @@ pub(crate) struct MockDatabase {
 }
 
 impl MockDatabase {
-    pub(crate) fn with_files(fixture: &str) -> (MockDatabase, FileMap) {
-        let (db, file_map, position) = MockDatabase::from_fixture(fixture);
+    pub(crate) fn with_files(fixture: &str) -> (MockDatabase, SourceRoot) {
+        let (db, source_root, position) = MockDatabase::from_fixture(fixture);
         assert!(position.is_none());
-        (db, file_map)
+        (db, source_root)
     }
 
     pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
@@ -33,48 +35,50 @@ impl MockDatabase {
             .set((), Arc::new(crate_graph));
     }
 
-    fn from_fixture(fixture: &str) -> (MockDatabase, FileMap, Option<FilePosition>) {
+    fn from_fixture(fixture: &str) -> (MockDatabase, SourceRoot, Option<FilePosition>) {
         let mut db = MockDatabase::default();
 
         let mut position = None;
-        let mut file_map = FileMap::default();
+        let mut source_root = SourceRoot::default();
         for entry in parse_fixture(fixture) {
             if entry.text.contains(CURSOR_MARKER) {
                 assert!(
                     position.is_none(),
                     "only one marker (<|>) per fixture is allowed"
                 );
-                position = Some(db.add_file_with_position(&mut file_map, &entry.meta, &entry.text));
+                position =
+                    Some(db.add_file_with_position(&mut source_root, &entry.meta, &entry.text));
             } else {
-                db.add_file(&mut file_map, &entry.meta, &entry.text);
+                db.add_file(&mut source_root, &entry.meta, &entry.text);
             }
         }
-        let source_root = file_map.clone().into_source_root();
         db.query_mut(ra_db::SourceRootQuery)
-            .set(WORKSPACE, Arc::new(source_root));
-        (db, file_map, position)
+            .set(WORKSPACE, Arc::new(source_root.clone()));
+        (db, source_root, position)
     }
 
-    fn add_file(&mut self, file_map: &mut FileMap, path: &str, text: &str) -> FileId {
+    fn add_file(&mut self, source_root: &mut SourceRoot, path: &str, text: &str) -> FileId {
         assert!(path.starts_with('/'));
         let path = RelativePathBuf::from_path(&path[1..]).unwrap();
-
-        let file_id = file_map.add(path);
+        let file_id = FileId(source_root.files.len() as u32);
         let text = Arc::new(text.to_string());
         self.query_mut(ra_db::FileTextQuery).set(file_id, text);
+        self.query_mut(ra_db::FileRelativePathQuery)
+            .set(file_id, path.clone());
         self.query_mut(ra_db::FileSourceRootQuery)
             .set(file_id, WORKSPACE);
+        source_root.files.insert(path, file_id);
         file_id
     }
 
     fn add_file_with_position(
         &mut self,
-        file_map: &mut FileMap,
+        source_root: &mut SourceRoot,
         path: &str,
         text: &str,
     ) -> FilePosition {
         let (offset, text) = extract_offset(text);
-        let file_id = self.add_file(file_map, path, &text);
+        let file_id = self.add_file(source_root, path, &text);
         FilePosition { file_id, offset }
     }
 }
@@ -104,11 +108,11 @@ impl Default for MockDatabase {
             runtime: salsa::Runtime::default(),
             id_maps: Default::default(),
         };
-        db.query_mut(ra_db::SourceRootQuery)
-            .set(ra_db::WORKSPACE, Default::default());
         db.query_mut(ra_db::CrateGraphQuery)
             .set((), Default::default());
-        db.query_mut(ra_db::LibrariesQuery)
+        db.query_mut(ra_db::LocalRootsQuery)
+            .set((), Default::default());
+        db.query_mut(ra_db::LibraryRootsQuery)
             .set((), Default::default());
         db
     }
@@ -158,9 +162,11 @@ salsa::database_storage! {
     pub(crate) struct MockDatabaseStorage for MockDatabase {
         impl ra_db::FilesDatabase {
             fn file_text() for ra_db::FileTextQuery;
+            fn file_relative_path() for ra_db::FileRelativePathQuery;
             fn file_source_root() for ra_db::FileSourceRootQuery;
             fn source_root() for ra_db::SourceRootQuery;
-            fn libraries() for ra_db::LibrariesQuery;
+            fn local_roots() for ra_db::LocalRootsQuery;
+            fn library_roots() for ra_db::LibraryRootsQuery;
             fn crate_graph() for ra_db::CrateGraphQuery;
         }
         impl ra_db::SyntaxDatabase {
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);