Merge #234

234: Global module r=matklad a=matklad

This series of commits re-introdces `ModuleDescriptor` as one stop shop for all information about a module.

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

Author: bors[bot]

crates/ra_analysis/src/completion/mod.rs

@@ -2,7 +2,6 @@ mod reference_completion;
 
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    algo::find_leaf_at_offset,
     algo::visit::{visitor_ctx, VisitorCtx},
     ast,
     AstNode, AtomEdit,
@@ -12,8 +11,9 @@ use rustc_hash::{FxHashMap};
 
 use crate::{
     db::{self, SyntaxDatabase},
-    descriptors::{DescriptorDatabase, module::ModuleSource},
-    input::{FilesDatabase},
+    descriptors::{
+        module::{ModuleDescriptor}
+    },
     Cancelable, FilePosition
 };
 
@@ -38,14 +38,7 @@ pub(crate) fn completions(
         original_file.reparse(&edit)
     };
 
-    let leaf = match find_leaf_at_offset(original_file.syntax(), position.offset).left_biased() {
-        None => return Ok(None),
-        Some(it) => it,
-    };
-    let source_root_id = db.file_source_root(position.file_id);
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_source = ModuleSource::for_node(position.file_id, leaf);
-    let module_id = match module_tree.any_module_for_source(module_source) {
+    let module = match ModuleDescriptor::guess_from_position(db, position)? {
         None => return Ok(None),
         Some(it) => it,
     };
@@ -55,15 +48,7 @@ pub(crate) fn completions(
     // First, let's try to complete a reference to some declaration.
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
         has_completions = true;
-        reference_completion::completions(
-            &mut res,
-            db,
-            source_root_id,
-            &module_tree,
-            module_id,
-            &file,
-            name_ref,
-        )?;
+        reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
         // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
         if is_node::<ast::Param>(name_ref.syntax()) {
             param_completions(name_ref.syntax(), &mut res);

crates/ra_analysis/src/completion/reference_completion.rs

@@ -9,20 +9,16 @@ use ra_syntax::{
 
 use crate::{
     db::RootDatabase,
-    input::{SourceRootId},
     completion::CompletionItem,
-    descriptors::module::{ModuleId, ModuleTree},
+    descriptors::module::{ModuleDescriptor},
     descriptors::function::FnScopes,
-    descriptors::DescriptorDatabase,
     Cancelable
 };
 
 pub(super) fn completions(
     acc: &mut Vec<CompletionItem>,
     db: &RootDatabase,
-    source_root_id: SourceRootId,
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
+    module: &ModuleDescriptor,
     file: &SourceFileNode,
     name_ref: ast::NameRef,
 ) -> Cancelable<()> {
@@ -40,7 +36,7 @@ pub(super) fn completions(
                 complete_expr_snippets(acc);
             }
 
-            let module_scope = db.module_scope(source_root_id, module_id)?;
+            let module_scope = module.scope(db)?;
             acc.extend(
                 module_scope
                     .entries()
@@ -56,9 +52,7 @@ pub(super) fn completions(
                     }),
             );
         }
-        NameRefKind::CratePath(path) => {
-            complete_path(acc, db, source_root_id, module_tree, module_id, path)?
-        }
+        NameRefKind::CratePath(path) => complete_path(acc, db, module, path)?,
         NameRefKind::BareIdentInMod => {
             let name_range = name_ref.syntax().range();
             let top_node = name_ref
@@ -171,16 +165,14 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
 fn complete_path(
     acc: &mut Vec<CompletionItem>,
     db: &RootDatabase,
-    source_root_id: SourceRootId,
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
+    module: &ModuleDescriptor,
     crate_path: Vec<ast::NameRef>,
 ) -> Cancelable<()> {
-    let target_module_id = match find_target_module(module_tree, module_id, crate_path) {
+    let target_module = match find_target_module(module, crate_path) {
         None => return Ok(()),
         Some(it) => it,
     };
-    let module_scope = db.module_scope(source_root_id, target_module_id)?;
+    let module_scope = target_module.scope(db)?;
     let completions = module_scope.entries().iter().map(|entry| CompletionItem {
         label: entry.name().to_string(),
         lookup: None,
@@ -191,14 +183,13 @@ fn complete_path(
 }
 
 fn find_target_module(
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
+    module: &ModuleDescriptor,
     mut crate_path: Vec<ast::NameRef>,
-) -> Option<ModuleId> {
+) -> Option<ModuleDescriptor> {
     crate_path.pop();
-    let mut target_module = module_id.root(&module_tree);
+    let mut target_module = module.crate_root();
     for name in crate_path {
-        target_module = target_module.child(module_tree, name.text().as_str())?;
+        target_module = target_module.child(name.text().as_str())?;
     }
     Some(target_module)
 }

crates/ra_analysis/src/db.rs

@@ -85,10 +85,10 @@ salsa::database_storage! {
         }
         impl DescriptorDatabase {
             fn module_tree() for ModuleTreeQuery;
-            fn module_descriptor() for SubmodulesQuery;
             fn module_scope() for ModuleScopeQuery;
-            fn fn_syntax() for FnSyntaxQuery;
             fn fn_scopes() for FnScopesQuery;
+            fn _fn_syntax() for FnSyntaxQuery;
+            fn _submodules() for SubmodulesQuery;
         }
     }
 }

crates/ra_analysis/src/descriptors/function/imp.rs

@@ -15,7 +15,7 @@ pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode
 }
 
 pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> {
-    let syntax = db.fn_syntax(fn_id);
+    let syntax = db._fn_syntax(fn_id);
     let res = FnScopes::new(syntax.borrowed());
     Arc::new(res)
 }

crates/ra_analysis/src/descriptors/mod.rs

@@ -20,27 +20,28 @@ use crate::{
 
 salsa::query_group! {
     pub(crate) trait DescriptorDatabase: SyntaxDatabase + IdDatabase {
-        fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
+        fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
+            type FnScopesQuery;
+            use fn function::imp::fn_scopes;
+        }
+
+        fn _module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
             type ModuleTreeQuery;
             use fn module::imp::module_tree;
         }
-        fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
-            type SubmodulesQuery;
-            use fn module::imp::submodules;
-        }
-        fn module_scope(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleScope>> {
+        fn _module_scope(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleScope>> {
             type ModuleScopeQuery;
             use fn module::imp::module_scope;
         }
-        fn fn_syntax(fn_id: FnId) -> FnDefNode {
+        fn _fn_syntax(fn_id: FnId) -> FnDefNode {
             type FnSyntaxQuery;
             // Don't retain syntax trees in memory
             storage volatile;
             use fn function::imp::fn_syntax;
         }
-        fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
-            type FnScopesQuery;
-            use fn function::imp::fn_scopes;
+        fn _submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
+            type SubmodulesQuery;
+            use fn module::imp::submodules;
         }
     }
 }

crates/ra_analysis/src/descriptors/module/imp.rs

@@ -86,7 +86,7 @@ pub(crate) fn module_scope(
     source_root_id: SourceRootId,
     module_id: ModuleId,
 ) -> Cancelable<Arc<ModuleScope>> {
-    let tree = db.module_tree(source_root_id)?;
+    let tree = db._module_tree(source_root_id)?;
     let source = module_id.source(&tree).resolve(db);
     let res = match source {
         ModuleSourceNode::SourceFile(it) => ModuleScope::new(it.borrowed().items()),
@@ -155,7 +155,7 @@ fn build_subtree(
         parent,
         children: Vec::new(),
     });
-    for sub in db.submodules(source)?.iter() {
+    for sub in db._submodules(source)?.iter() {
         let link = tree.push_link(LinkData {
             name: sub.name().clone(),
             owner: id,