Merge #693

693: Name resolution refactoring r=matklad a=flodiebold

This is still very WIP, but it's becoming quite big and I want to make sure this isn't going in a completely bad direction :sweat_smile:. I'm not really happy with how the path resolution looks, and I'm not sure `PerNs<Resolution>` is the best return type -- there are 'this cannot happen in the (types/values) namespace' cases everywhere. I also want to unify the `resolver` and `nameres` namespaces once I'm done switching everything to `Resolver`. Also, `Resolver` only has a lifetime because it needs to have a reference to the `ItemMap` during import resolution :confused: 

The differences in the completion snapshots are almost completely just ordering (except it completes `Self` as well now), so I changed it to sort the completions before snapshotting.

Co-authored-by: Florian Diebold <[email protected]>

1 files changed, 67 insertions, 2 deletions

diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index a1b94ed9c..59f782277 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -9,13 +9,14 @@ use ra_db::{FileId, FilePosition};
 use ra_syntax::{
     SmolStr, TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner},
-    algo::find_node_at_offset,
+    algo::{find_node_at_offset, find_leaf_at_offset},
 };
 
 use crate::{
     HirDatabase, Function, ModuleDef, Struct, Enum,
-    AsName, Module, HirFileId, Crate, Trait,
+    AsName, Module, HirFileId, Crate, Trait, Resolver,
     ids::{LocationCtx, SourceFileItemId},
+    expr
 };
 
 /// Locates the module by `FileId`. Picks topmost module in the file.
@@ -201,3 +202,67 @@ pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, Te
 
     res
 }
+
+pub fn resolver_for_position(db: &impl HirDatabase, position: FilePosition) -> Resolver {
+    let file_id = position.file_id;
+    let file = db.parse(file_id);
+    find_leaf_at_offset(file.syntax(), position.offset)
+        .find_map(|node| {
+            node.ancestors().find_map(|node| {
+                if ast::Expr::cast(node).is_some() || ast::Block::cast(node).is_some() {
+                    if let Some(func) = function_from_child_node(db, file_id, node) {
+                        let scopes = func.scopes(db);
+                        let scope = scopes.scope_for_offset(position.offset);
+                        Some(expr::resolver_for_scope(func.body(db), db, scope))
+                    } else {
+                        // TODO const/static/array length
+                        None
+                    }
+                } else if let Some(module) = ast::Module::cast(node) {
+                    Some(module_from_declaration(db, file_id, module)?.resolver(db))
+                } else if let Some(_) = ast::SourceFile::cast(node) {
+                    Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+                } else if let Some(s) = ast::StructDef::cast(node) {
+                    let module = module_from_child_node(db, file_id, s.syntax())?;
+                    Some(struct_from_module(db, module, s).resolver(db))
+                } else if let Some(e) = ast::EnumDef::cast(node) {
+                    let module = module_from_child_node(db, file_id, e.syntax())?;
+                    Some(enum_from_module(db, module, e).resolver(db))
+                } else {
+                    // TODO add missing cases
+                    None
+                }
+            })
+        })
+        .unwrap_or_default()
+}
+
+pub fn resolver_for_node(db: &impl HirDatabase, file_id: FileId, node: &SyntaxNode) -> Resolver {
+    node.ancestors()
+        .find_map(|node| {
+            if ast::Expr::cast(node).is_some() || ast::Block::cast(node).is_some() {
+                if let Some(func) = function_from_child_node(db, file_id, node) {
+                    let scopes = func.scopes(db);
+                    let scope = scopes.scope_for(&node);
+                    Some(expr::resolver_for_scope(func.body(db), db, scope))
+                } else {
+                    // TODO const/static/array length
+                    None
+                }
+            } else if let Some(module) = ast::Module::cast(node) {
+                Some(module_from_declaration(db, file_id, module)?.resolver(db))
+            } else if let Some(_) = ast::SourceFile::cast(node) {
+                Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+            } else if let Some(s) = ast::StructDef::cast(node) {
+                let module = module_from_child_node(db, file_id, s.syntax())?;
+                Some(struct_from_module(db, module, s).resolver(db))
+            } else if let Some(e) = ast::EnumDef::cast(node) {
+                let module = module_from_child_node(db, file_id, e.syntax())?;
+                Some(enum_from_module(db, module, e).resolver(db))
+            } else {
+                // TODO add missing cases
+                None
+            }
+        })
+        .unwrap_or_default()
+}