Merge #429

429: Reorganize hir public API in terms of code model r=matklad a=matklad

Recently, I've been thinking about introducing "object orient code model" API for rust: a set of APIs with types like `Function`, `Module`, etc, with methods like `get_containing_declaration()`, `get_type()`, etc. 

Here's how a similar API might look like in .Net land:

https://docs.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.semanticmodel?view=roslyn-dotnet

https://docs.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.imethodsymbol?view=roslyn-dotnet

The main feature of such API is that it can be powered by different backends. For example, one can imagine a backend based on salsa, and a backend which reads all the data from a specially prepared JSON file. The "OO" bit is interesting mostly in this "can swap implementations via dynamic dispatch" aspect, the actual API could have a more database/ECS flavored feeling.

It's not clear at this moment how exactly should we implement such a dynamically (or if we even need dynamism in the first pace) swapable API in Rust, but I'd love to experiment with this a bit. 

For starters, I propose creating a `code_model_api` which contains various definition types and their public methods (mandatory implemented as one-liners, so that the API has a header-file feel). Specifically, I propose that each type is a wrapper around some integer ID, and that all methods of it accept a `&db` argument.  The actual impl goes elsewhere: into the db queries or, absent a better place, into the `code_model_api_impl`. In the first commit, I've moved the simplest type, `Crate`, over to this pattern.

I *think* that we, at least initially, will be used types from `code_model_api` *inside* `hir` as well, but this is not required: we might pick a different implementation down the line, while preserving the API. 

Long term I'd love to replace the `db: &impl HirDatabase` argument by a `mp: &dyn ModelProvider`, implement `ModelProvider` for `T: HirDatabase`, and move `code_model_api` into the separate crate, which does not depend on `hir`. 

@flodiebold you've recently done some `Def`s work, would do you think of this plan? Could it become a good API in the future, or is it just a useless boilerplate duplicating method signatures between `code_model_api` and `code_model_impl`?


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

2 files changed, 199 insertions, 0 deletions

diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
new file mode 100644
index 000000000..591a81597
--- /dev/null
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -0,0 +1,45 @@
+use ra_db::{CrateId, Cancelable};
+
+use crate::{
+    HirFileId, Crate, CrateDependency, AsName, DefLoc, DefKind, Module,
+    db::HirDatabase,
+};
+
+impl Crate {
+    pub(crate) fn new(crate_id: CrateId) -> Crate {
+        Crate { crate_id }
+    }
+    pub(crate) fn dependencies_impl(&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.as_name();
+                CrateDependency { krate, name }
+            })
+            .collect()
+    }
+    pub(crate) fn root_module_impl(&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 file_id = HirFileId::from(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 def_loc = DefLoc {
+            kind: DefKind::Module,
+            source_root_id,
+            module_id,
+            source_item_id: module_id.source(&module_tree).0,
+        };
+        let def_id = def_loc.id(db);
+
+        let module = Module::new(def_id);
+        Ok(Some(module))
+    }
+}
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
new file mode 100644
index 000000000..02078f188
--- /dev/null
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -0,0 +1,154 @@
+use ra_db::{Cancelable, SourceRootId, FileId};
+use ra_syntax::{ast, SyntaxNode, AstNode};
+
+use crate::{
+    Module, ModuleSource, Problem,
+    Crate, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def, ModuleId,
+    nameres::ModuleScope,
+    db::HirDatabase,
+};
+
+impl Module {
+    pub(crate) fn new(def_id: DefId) -> Self {
+        crate::code_model_api::Module { def_id }
+    }
+    pub(crate) fn from_module_id(
+        db: &impl HirDatabase,
+        source_root_id: SourceRootId,
+        module_id: ModuleId,
+    ) -> Cancelable<Self> {
+        let module_tree = db.module_tree(source_root_id)?;
+        let def_loc = DefLoc {
+            kind: DefKind::Module,
+            source_root_id,
+            module_id,
+            source_item_id: module_id.source(&module_tree).0,
+        };
+        let def_id = def_loc.id(db);
+        let module = Module::new(def_id);
+        Ok(module)
+    }
+
+    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        let link = ctry!(loc.module_id.parent_link(&module_tree));
+        Ok(Some(link.name(&module_tree).clone()))
+    }
+
+    pub fn defenition_source_impl(
+        &self,
+        db: &impl HirDatabase,
+    ) -> Cancelable<(FileId, ModuleSource)> {
+        let loc = self.def_id.loc(db);
+        let file_id = loc.source_item_id.file_id.as_original_file();
+        let syntax_node = db.file_item(loc.source_item_id);
+        let syntax_node = syntax_node.borrowed();
+        let module_source = if let Some(source_file) = ast::SourceFile::cast(syntax_node) {
+            ModuleSource::SourceFile(source_file.owned())
+        } else {
+            let module = ast::Module::cast(syntax_node).unwrap();
+            ModuleSource::Module(module.owned())
+        };
+        Ok((file_id, module_source))
+    }
+
+    pub fn declaration_source_impl(
+        &self,
+        db: &impl HirDatabase,
+    ) -> Cancelable<Option<(FileId, ast::ModuleNode)>> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        let link = ctry!(loc.module_id.parent_link(&module_tree));
+        let file_id = link
+            .owner(&module_tree)
+            .source(&module_tree)
+            .file_id()
+            .as_original_file();
+        let src = link.bind_source(&module_tree, db);
+        Ok(Some((file_id, src)))
+    }
+
+    pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
+        let root = self.crate_root(db)?;
+        let loc = root.def_id.loc(db);
+        let file_id = loc.source_item_id.file_id.as_original_file();
+
+        let crate_graph = db.crate_graph();
+        let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id));
+        Ok(Some(Crate::new(crate_id)))
+    }
+
+    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_id = loc.module_id.crate_root(&module_tree);
+        Module::from_module_id(db, loc.source_root_id, module_id)
+    }
+    /// Finds a child module with the specified name.
+    pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        let child_id = ctry!(loc.module_id.child(&module_tree, name));
+        Module::from_module_id(db, loc.source_root_id, child_id).map(Some)
+    }
+    pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        let parent_id = ctry!(loc.module_id.parent(&module_tree));
+        Module::from_module_id(db, loc.source_root_id, parent_id).map(Some)
+    }
+    /// Returns a `ModuleScope`: a set of items, visible in this module.
+    pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
+        let loc = self.def_id.loc(db);
+        let item_map = db.item_map(loc.source_root_id)?;
+        let res = item_map.per_module[&loc.module_id].clone();
+        Ok(res)
+    }
+    pub fn resolve_path_impl(
+        &self,
+        db: &impl HirDatabase,
+        path: &Path,
+    ) -> Cancelable<PerNs<DefId>> {
+        let mut curr_per_ns = PerNs::types(
+            match path.kind {
+                PathKind::Crate => self.crate_root(db)?,
+                PathKind::Self_ | PathKind::Plain => self.clone(),
+                PathKind::Super => {
+                    if let Some(p) = self.parent(db)? {
+                        p
+                    } else {
+                        return Ok(PerNs::none());
+                    }
+                }
+            }
+            .def_id,
+        );
+
+        let segments = &path.segments;
+        for name in segments.iter() {
+            let curr = if let Some(r) = curr_per_ns.as_ref().take_types() {
+                r
+            } else {
+                return Ok(PerNs::none());
+            };
+            let module = match curr.resolve(db)? {
+                Def::Module(it) => it,
+                // TODO here would be the place to handle enum variants...
+                _ => return Ok(PerNs::none()),
+            };
+            let scope = module.scope(db)?;
+            curr_per_ns = if let Some(r) = scope.get(&name) {
+                r.def_id
+            } else {
+                return Ok(PerNs::none());
+            };
+        }
+        Ok(curr_per_ns)
+    }
+    pub fn problems_impl(&self, db: &impl HirDatabase) -> Cancelable<Vec<(SyntaxNode, Problem)>> {
+        let loc = self.def_id.loc(db);
+        let module_tree = db.module_tree(loc.source_root_id)?;
+        Ok(loc.module_id.problems(&module_tree, db))
+    }
+}