hide resolver

crates/ra_hir/src/source_binder.rs

@@ -7,7 +7,7 @@
 /// purely for "IDE needs".
 use std::sync::Arc;
 
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashSet, FxHashMap};
 use ra_db::{FileId, FilePosition};
 use ra_syntax::{
     SyntaxNode, AstPtr, TextUnit, SyntaxNodePtr,
@@ -17,7 +17,7 @@ use ra_syntax::{
 };
 
 use crate::{
-    HirDatabase, Function, Struct, Enum, Const, Static, Either, DefWithBody,
+    HirDatabase, Function, Struct, Enum, Const, Static, Either, DefWithBody, PerNs, Name,
     AsName, Module, HirFileId, Crate, Trait, Resolver,
     expr::{BodySourceMap, scope::{ReferenceDescriptor, ScopeEntryWithSyntax, ScopeId, ExprScopes}},
     ids::LocationCtx,
@@ -222,10 +222,6 @@ impl SourceAnalyzer {
         }
     }
 
-    pub fn resolver(&self) -> &Resolver {
-        &self.resolver
-    }
-
     pub fn type_of(&self, _db: &impl HirDatabase, expr: &ast::Expr) -> Option<crate::Ty> {
         let expr_id = self.body_source_map.as_ref()?.node_expr(expr)?;
         Some(self.infer.as_ref()?[expr_id].clone())
@@ -246,6 +242,18 @@ impl SourceAnalyzer {
         self.infer.as_ref()?.field_resolution(expr_id)
     }
 
+    pub fn resolve_hir_path(
+        &self,
+        db: &impl HirDatabase,
+        path: &crate::Path,
+    ) -> PerNs<crate::Resolution> {
+        self.resolver.resolve_path(db, path)
+    }
+
+    pub fn all_names(&self, db: &impl HirDatabase) -> FxHashMap<Name, PerNs<crate::Resolution>> {
+        self.resolver.all_names(db)
+    }
+
     pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
         if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
             let expr_id = self.body_source_map.as_ref()?.node_expr(path_expr.into())?;

crates/ra_ide_api/src/completion/complete_path.rs

@@ -9,7 +9,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
         Some(path) => path.clone(),
         _ => return,
     };
-    let def = match ctx.analyzer.resolver().resolve_path(ctx.db, &path).take_types() {
+    let def = match ctx.analyzer.resolve_hir_path(ctx.db, &path).take_types() {
         Some(Resolution::Def(def)) => def,
         _ => return,
     };

crates/ra_ide_api/src/completion/complete_pattern.rs

@@ -7,7 +7,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     }
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
-    let names = ctx.analyzer.resolver().all_names(ctx.db);
+    let names = ctx.analyzer.all_names(ctx.db);
     for (name, res) in names.into_iter() {
         let r = res.as_ref();
         let def = match r.take_types().or(r.take_values()) {

crates/ra_ide_api/src/completion/complete_scope.rs

@@ -4,7 +4,7 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_trivial_path {
         return;
     }
-    let names = ctx.analyzer.resolver().all_names(ctx.db);
+    let names = ctx.analyzer.all_names(ctx.db);
 
     names.into_iter().for_each(|(name, res)| acc.add_resolution(ctx, name.to_string(), &res));
 }