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]>

1 files changed, 20 insertions, 8 deletions

diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 29a3960e9..b7e3ff9b0 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -13,11 +13,13 @@ use ra_syntax::{
 };
 
 use crate::{
-    HirDatabase, Module, Function, SourceItemId,
-    module::ModuleSource,
+    HirDatabase, Function, SourceItemId,
+    module_tree::ModuleSource,
     DefKind, DefLoc, AsName,
 };
 
+use crate::code_model_api::Module;
+
 /// Locates the module by `FileId`. Picks topmost module in the file.
 pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable<Option<Module>> {
     let module_source = ModuleSource::new_file(file_id.into());
@@ -34,7 +36,7 @@ pub fn module_from_declaration(
     let child_name = decl.name();
     match (parent_module, child_name) {
         (Some(parent_module), Some(child_name)) => {
-            if let Some(child) = parent_module.child(&child_name.as_name()) {
+            if let Some(child) = parent_module.child(db, &child_name.as_name())? {
                 return Ok(Some(child));
             }
         }
@@ -84,7 +86,15 @@ fn module_from_source(
         .modules_with_sources()
         .find(|(_id, src)| src == &module_source);
     let module_id = ctry!(m).0;
-    Ok(Some(Module::new(db, source_root_id, module_id)?))
+    let def_loc = DefLoc {
+        kind: DefKind::Module,
+        source_root_id,
+        module_id,
+        source_item_id: module_source.0,
+    };
+    let def_id = def_loc.id(db);
+
+    Ok(Some(Module::new(def_id)))
 }
 
 pub fn function_from_position(
@@ -114,7 +124,8 @@ pub fn function_from_module(
     module: &Module,
     fn_def: ast::FnDef,
 ) -> Function {
-    let file_id = module.source().file_id();
+    let loc = module.def_id.loc(db);
+    let file_id = loc.source_item_id.file_id;
     let file_items = db.file_items(file_id);
     let item_id = file_items.id_of(file_id, fn_def.syntax());
     let source_item_id = SourceItemId {
@@ -123,8 +134,8 @@ pub fn function_from_module(
     };
     let def_loc = DefLoc {
         kind: DefKind::Function,
-        source_root_id: module.source_root_id,
-        module_id: module.module_id,
+        source_root_id: loc.source_root_id,
+        module_id: loc.module_id,
         source_item_id,
     };
     Function::new(def_loc.id(db))
@@ -147,7 +158,8 @@ pub fn macro_symbols(
         Some(it) => it,
         None => return Ok(Vec::new()),
     };
-    let items = db.input_module_items(module.source_root_id, module.module_id)?;
+    let loc = module.def_id.loc(db);
+    let items = db.input_module_items(loc.source_root_id, loc.module_id)?;
     let mut res = Vec::new();
 
     for macro_call_id in items