Merge #268

268: WIP: resolve imports across crates r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [ "crates/*" ]
-exclude = [ "crates/rowan"]
 
 [profile.release]
 debug = true

crates/ra_db/src/input.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashSet, FxHashMap};
+use ra_syntax::SmolStr;
 use salsa;
 
 use crate::file_resolver::FileResolverImp;
@@ -20,25 +20,32 @@ pub struct CrateGraph {
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct CrateData {
     file_id: FileId,
-    deps: Vec<Dependency>,
+    dependencies: Vec<Dependency>,
 }
 
 impl CrateData {
     fn new(file_id: FileId) -> CrateData {
         CrateData {
             file_id,
-            deps: Vec::new(),
+            dependencies: Vec::new(),
         }
     }
 
-    fn add_dep(&mut self, dep: CrateId) {
-        self.deps.push(Dependency { crate_: dep })
+    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
+        self.dependencies.push(Dependency { name, crate_id })
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Dependency {
-    crate_: CrateId,
+    pub crate_id: CrateId,
+    pub name: SmolStr,
+}
+
+impl Dependency {
+    pub fn crate_id(&self) -> CrateId {
+        self.crate_id
+    }
 }
 
 impl CrateGraph {
@@ -48,8 +55,11 @@ impl CrateGraph {
         assert!(prev.is_none());
         crate_id
     }
-    pub fn add_dep(&mut self, from: CrateId, to: CrateId) {
-        self.arena.get_mut(&from).unwrap().add_dep(to)
+    //FIXME: check that we don't have cycles here.
+    // Just a simple depth first search from `to` should work,
+    // the graph is small.
+    pub fn add_dep(&mut self, from: CrateId, name: SmolStr, to: CrateId) {
+        self.arena.get_mut(&from).unwrap().add_dep(name, to)
     }
     pub fn crate_root(&self, crate_id: CrateId) -> FileId {
         self.arena[&crate_id].file_id
@@ -61,6 +71,12 @@ impl CrateGraph {
             .find(|(_crate_id, data)| data.file_id == file_id)?;
         Some(crate_id)
     }
+    pub fn dependencies<'a>(
+        &'a self,
+        crate_id: CrateId,
+    ) -> impl Iterator<Item = &'a Dependency> + 'a {
+        self.arena[&crate_id].dependencies.iter()
+    }
 }
 
 salsa::query_group! {

crates/ra_db/src/mock.rs

@@ -5,7 +5,7 @@ use relative_path::{RelativePath, RelativePathBuf};
 
 use crate::{FileId, FileResolver, SourceRoot, FileResolverImp};
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub struct FileMap(Vec<(FileId, RelativePathBuf)>);
 
 impl FileMap {
@@ -28,6 +28,11 @@ impl FileMap {
         self.iter().map(|(id, _)| id).collect()
     }
 
+    pub fn file_id(&self, path: &str) -> FileId {
+        assert!(path.starts_with('/'));
+        self.iter().find(|(_, p)| p == &path[1..]).unwrap().0
+    }
+
     fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
         self.0
             .iter()

crates/ra_hir/src/krate.rs

@@ -0,0 +1,48 @@
+use ra_syntax::SmolStr;
+pub use ra_db::CrateId;
+
+use crate::{HirDatabase, Module, Cancelable};
+
+/// hir::Crate describes a single crate. It's the main inteface with which
+/// crate's dependencies interact. Mostly, it should be just a proxy for the
+/// root module.
+#[derive(Debug)]
+pub struct Crate {
+    crate_id: CrateId,
+}
+
+#[derive(Debug)]
+pub struct CrateDependency {
+    pub krate: Crate,
+    pub name: SmolStr,
+}
+
+impl Crate {
+    pub(crate) fn new(crate_id: CrateId) -> Crate {
+        Crate { crate_id }
+    }
+    pub fn dependencies(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
+        let crate_graph = db.crate_graph();
+        crate_graph
+            .dependencies(self.crate_id)
+            .map(|dep| {
+                let krate = Crate::new(dep.crate_id());
+                let name = dep.name.clone();
+                CrateDependency { krate, name }
+            })
+            .collect()
+    }
+    pub fn root_module(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+        let crate_graph = db.crate_graph();
+        let file_id = crate_graph.crate_root(self.crate_id);
+        let source_root_id = db.file_source_root(file_id);
+        let module_tree = db.module_tree(source_root_id)?;
+        // FIXME: teach module tree about crate roots instead of guessing
+        let (module_id, _) = ctry!(module_tree
+            .modules_with_sources()
+            .find(|(_, src)| src.file_id() == file_id));
+
+        let module = Module::new(db, source_root_id, module_id)?;
+        Ok(Some(module))
+    }
+}

crates/ra_hir/src/lib.rs

@@ -18,12 +18,14 @@ pub mod db;
 #[cfg(test)]
 mod mock;
 mod query_definitions;
-mod function;
-mod module;
 mod path;
 mod arena;
 pub mod source_binder;
 
+mod krate;
+mod module;
+mod function;
+
 use std::ops::Index;
 
 use ra_syntax::{SyntaxNodeRef, SyntaxNode};
@@ -36,6 +38,7 @@ use crate::{
 
 pub use self::{
     path::{Path, PathKind},
+    krate::Crate,
     module::{Module, ModuleId, Problem, nameres::ItemMap},
     function::{Function, FnScopes},
 };

crates/ra_hir/src/mock.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use parking_lot::Mutex;
 use salsa::{self, Database};
-use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE};
+use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE, CrateGraph};
 use relative_path::RelativePathBuf;
 use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
 
@@ -16,7 +16,24 @@ pub(crate) struct MockDatabase {
 }
 
 impl MockDatabase {
+    pub(crate) fn with_files(fixture: &str) -> (MockDatabase, FileMap) {
+        let (db, file_map, position) = MockDatabase::from_fixture(fixture);
+        assert!(position.is_none());
+        (db, file_map)
+    }
+
     pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
+        let (db, _, position) = MockDatabase::from_fixture(fixture);
+        let position = position.expect("expected a marker ( <|> )");
+        (db, position)
+    }
+
+    pub(crate) fn set_crate_graph(&mut self, crate_graph: CrateGraph) {
+        self.query_mut(ra_db::CrateGraphQuery)
+            .set((), Arc::new(crate_graph));
+    }
+
+    fn from_fixture(fixture: &str) -> (MockDatabase, FileMap, Option<FilePosition>) {
         let mut db = MockDatabase::default();
 
         let mut position = None;
@@ -32,11 +49,10 @@ impl MockDatabase {
                 db.add_file(&mut file_map, &entry.meta, &entry.text);
             }
         }
-        let position = position.expect("expected a marker (<|>)");
-        let source_root = file_map.into_source_root();
+        let source_root = file_map.clone().into_source_root();
         db.query_mut(ra_db::SourceRootQuery)
             .set(WORKSPACE, Arc::new(source_root));
-        (db, position)
+        (db, file_map, position)
     }
 
     fn add_file(&mut self, file_map: &mut FileMap, path: &str, text: &str) -> FileId {

crates/ra_hir/src/module.rs

@@ -12,7 +12,7 @@ use ra_db::{SourceRootId, FileId, Cancelable};
 use relative_path::RelativePathBuf;
 
 use crate::{
-    DefKind, DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId,
+    DefKind, DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId, Crate,
     arena::{Arena, Id},
 };
 
@@ -64,6 +64,15 @@ impl Module {
         })
     }
 
+    /// Returns the crate this module is part of.
+    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
+        let root_id = self.module_id.crate_root(&self.tree);
+        let file_id = root_id.source(&self.tree).file_id();
+        let crate_graph = db.crate_graph();
+        let crate_id = crate_graph.crate_id_for_crate_root(file_id)?;
+        Some(Crate::new(crate_id))
+    }
+
     /// The root of the tree this module is part of
     pub fn crate_root(&self) -> Module {
         let root_id = self.module_id.crate_root(&self.tree);