1 files changed, 28 insertions, 26 deletions
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 589a9b2db..817e660f9 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -10,13 +10,13 @@ use ra_syntax::{
 };
 use crate::{
-    Path, Name, HirDatabase, Resolver,DefWithBody,
+    Path, Name, HirDatabase, Resolver,DefWithBody, Either,
    name::AsName,
    type_ref::{Mutability, TypeRef},
 };
-use crate::{ path::GenericArgs, ty::primitive::{IntTy, UncertainIntTy, FloatTy, UncertainFloatTy}};
+use crate::{path::GenericArgs, ty::primitive::{IntTy, UncertainIntTy, FloatTy, UncertainFloatTy}};
-pub use self::scope::{ExprScopes, ScopesWithSourceMap, ScopeEntryWithSyntax};
+pub use self::scope::ExprScopes;
 pub(crate) mod scope;
@@ -51,11 +51,13 @@ pub struct Body {
 pub struct BodySourceMap {
    expr_map: FxHashMap<SyntaxNodePtr, ExprId>,
    expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>,
-    pat_map: FxHashMap<SyntaxNodePtr, PatId>,
+    pat_map: FxHashMap<PatPtr, PatId>,
-    pat_map_back: ArenaMap<PatId, SyntaxNodePtr>,
+    pat_map_back: ArenaMap<PatId, PatPtr>,
    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::NamedField>>,
 }
+type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
 impl Body {
    pub fn params(&self) -> &[PatId] {
        &self.params
@@ -79,19 +81,23 @@ impl Body {
 }
 // needs arbitrary_self_types to be a method... or maybe move to the def?
-pub fn resolver_for_expr(body: Arc<Body>, db: &impl HirDatabase, expr_id: ExprId) -> Resolver {
+pub(crate) fn resolver_for_expr(
+    body: Arc<Body>,
+    db: &impl HirDatabase,
+    expr_id: ExprId,
+) -> Resolver {
    let scopes = db.expr_scopes(body.owner);
    resolver_for_scope(body, db, scopes.scope_for(expr_id))
 }
-pub fn resolver_for_scope(
+pub(crate) fn resolver_for_scope(
    body: Arc<Body>,
    db: &impl HirDatabase,
    scope_id: Option<scope::ScopeId>,
 ) -> Resolver {
    let mut r = body.owner.resolver(db);
    let scopes = db.expr_scopes(body.owner);
-    let scope_chain = scopes.scope_chain_for(scope_id).collect::<Vec<_>>();
+    let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
    for scope in scope_chain.into_iter().rev() {
        r = r.push_expr_scope(Arc::clone(&scopes), scope);
    }
@@ -115,31 +121,27 @@ impl Index<PatId> for Body {
 }
 impl BodySourceMap {
-    pub fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> {
+    pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> {
        self.expr_map_back.get(expr).cloned()
    }
-    pub fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> {
+    pub(crate) fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> {
        self.expr_map.get(&ptr).cloned()
    }
-    pub fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
+    pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
        self.expr_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
    }
-    pub fn pat_syntax(&self, pat: PatId) -> Option<SyntaxNodePtr> {
+    pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatPtr> {
        self.pat_map_back.get(pat).cloned()
    }
-    pub fn syntax_pat(&self, ptr: SyntaxNodePtr) -> Option<PatId> {
+    pub(crate) fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
-        self.pat_map.get(&ptr).cloned()
+        self.pat_map.get(&Either::A(AstPtr::new(node))).cloned()
-    }
-    pub fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
-        self.pat_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
    }
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::NamedField> {
+    pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::NamedField> {
        self.field_map[&(expr, field)].clone()
    }
 }
@@ -504,10 +506,10 @@ impl ExprCollector {
        id
    }
-    fn alloc_pat(&mut self, pat: Pat, syntax_ptr: SyntaxNodePtr) -> PatId {
+    fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
        let id = self.pats.alloc(pat);
-        self.source_map.pat_map.insert(syntax_ptr, id);
+        self.source_map.pat_map.insert(ptr, id);
-        self.source_map.pat_map_back.insert(id, syntax_ptr);
+        self.source_map.pat_map_back.insert(id, ptr);
        id
    }
@@ -886,8 +888,8 @@ impl ExprCollector {
            ast::PatKind::LiteralPat(_) => Pat::Missing,
            ast::PatKind::SlicePat(_) | ast::PatKind::RangePat(_) => Pat::Missing,
        };
-        let syntax_ptr = SyntaxNodePtr::new(pat.syntax());
+        let ptr = AstPtr::new(pat);
-        self.alloc_pat(pattern, syntax_ptr)
+        self.alloc_pat(pattern, Either::A(ptr))
    }
    fn collect_pat_opt(&mut self, pat: Option<&ast::Pat>) -> PatId {
@@ -911,14 +913,14 @@ impl ExprCollector {
    fn collect_fn_body(&mut self, node: &ast::FnDef) {
        if let Some(param_list) = node.param_list() {
            if let Some(self_param) = param_list.self_param() {
-                let self_param = SyntaxNodePtr::new(self_param.syntax());
+                let ptr = AstPtr::new(self_param);
                let param_pat = self.alloc_pat(
                    Pat::Bind {
                        name: Name::self_param(),
                        mode: BindingAnnotation::Unannotated,
                        subpat: None,
                    },
-                    self_param,
+                    Either::B(ptr),
                );
                self.params.push(param_pat);
            }