1 files changed, 48 insertions, 35 deletions

diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 66cb4b357..ca40e3b54 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -7,8 +7,11 @@
 //! purely for "IDE needs".
 use std::sync::Arc;
 
-use hir_def::path::known;
-use hir_expand::name::AsName;
+use hir_def::{
+    expr::{ExprId, PatId},
+    path::known,
+};
+use hir_expand::{name::AsName, Source};
 use ra_db::FileId;
 use ra_syntax::{
     ast::{self, AstNode},
@@ -20,16 +23,12 @@ use rustc_hash::FxHashSet;
 
 use crate::{
     db::HirDatabase,
-    expr::{
-        self,
-        scope::{ExprScopes, ScopeId},
-        BodySourceMap,
-    },
+    expr::{self, BodySourceMap, ExprScopes, ScopeId},
     ids::LocationCtx,
     resolve::{ScopeDef, TypeNs, ValueNs},
     ty::method_resolution::{self, implements_trait},
-    AssocItem, Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId,
-    MacroDef, Module, Name, Path, Resolver, Static, Struct, Ty,
+    AssocItem, Const, DefWithBody, Either, Enum, FromSource, Function, GenericParam, HasBody,
+    HirFileId, Local, MacroDef, Module, Name, Path, Resolver, Static, Struct, Ty,
 };
 
 fn try_get_resolver_for_node(
@@ -93,7 +92,10 @@ fn def_with_body_from_child_node(
 /// original source files. It should not be used inside the HIR itself.
 #[derive(Debug)]
 pub struct SourceAnalyzer {
+    // FIXME: this doesn't handle macros at all
+    file_id: FileId,
     resolver: Resolver,
+    body_owner: Option<DefWithBody>,
     body_source_map: Option<Arc<BodySourceMap>>,
     infer: Option<Arc<crate::ty::InferenceResult>>,
     scopes: Option<Arc<crate::expr::ExprScopes>>,
@@ -104,9 +106,9 @@ pub enum PathResolution {
     /// An item
     Def(crate::ModuleDef),
     /// A local binding (only value namespace)
-    LocalBinding(Either<AstPtr<ast::BindPat>, AstPtr<ast::SelfParam>>),
+    Local(Local),
     /// A generic parameter
-    GenericParam(u32),
+    GenericParam(GenericParam),
     SelfType(crate::ImplBlock),
     Macro(MacroDef),
     AssocItem(crate::AssocItem),
@@ -144,17 +146,19 @@ impl SourceAnalyzer {
         let def_with_body = def_with_body_from_child_node(db, file_id, node);
         if let Some(def) = def_with_body {
             let source_map = def.body_source_map(db);
-            let scopes = db.expr_scopes(def);
+            let scopes = def.expr_scopes(db);
             let scope = match offset {
-                None => scope_for(&scopes, &source_map, &node),
+                None => scope_for(&scopes, &source_map, file_id.into(), &node),
                 Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset),
             };
-            let resolver = expr::resolver_for_scope(def.body(db), db, scope);
+            let resolver = expr::resolver_for_scope(db, def, scope);
             SourceAnalyzer {
                 resolver,
+                body_owner: Some(def),
                 body_source_map: Some(source_map),
                 infer: Some(def.infer(db)),
                 scopes: Some(scopes),
+                file_id,
             }
         } else {
             SourceAnalyzer {
@@ -162,20 +166,32 @@ impl SourceAnalyzer {
                     .ancestors()
                     .find_map(|node| try_get_resolver_for_node(db, file_id, &node))
                     .unwrap_or_default(),
+                body_owner: None,
                 body_source_map: None,
                 infer: None,
                 scopes: None,
+                file_id,
             }
         }
     }
 
+    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
+        let src = Source { file_id: self.file_id.into(), ast: expr };
+        self.body_source_map.as_ref()?.node_expr(src)
+    }
+
+    fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
+        let src = Source { file_id: self.file_id.into(), ast: pat };
+        self.body_source_map.as_ref()?.node_pat(src)
+    }
+
     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)?;
+        let expr_id = self.expr_id(expr)?;
         Some(self.infer.as_ref()?[expr_id].clone())
     }
 
     pub fn type_of_pat(&self, _db: &impl HirDatabase, pat: &ast::Pat) -> Option<crate::Ty> {
-        let pat_id = self.body_source_map.as_ref()?.node_pat(pat)?;
+        let pat_id = self.pat_id(pat)?;
         Some(self.infer.as_ref()?[pat_id].clone())
     }
 
@@ -188,22 +204,22 @@ impl SourceAnalyzer {
     }
 
     pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(&call.clone().into())?;
+        let expr_id = self.expr_id(&call.clone().into())?;
         self.infer.as_ref()?.method_resolution(expr_id)
     }
 
     pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(&field.clone().into())?;
+        let expr_id = self.expr_id(&field.clone().into())?;
         self.infer.as_ref()?.field_resolution(expr_id)
     }
 
     pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(&record_lit.clone().into())?;
+        let expr_id = self.expr_id(&record_lit.clone().into())?;
         self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
     }
 
     pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<crate::VariantDef> {
-        let pat_id = self.body_source_map.as_ref()?.node_pat(&record_pat.clone().into())?;
+        let pat_id = self.pat_id(&record_pat.clone().into())?;
         self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
     }
 
@@ -224,7 +240,10 @@ impl SourceAnalyzer {
     ) -> Option<PathResolution> {
         let types = self.resolver.resolve_path_in_type_ns_fully(db, &path).map(|ty| match ty {
             TypeNs::SelfType(it) => PathResolution::SelfType(it),
-            TypeNs::GenericParam(it) => PathResolution::GenericParam(it),
+            TypeNs::GenericParam(idx) => PathResolution::GenericParam(GenericParam {
+                parent: self.resolver.generic_def().unwrap(),
+                idx,
+            }),
             TypeNs::AdtSelfType(it) | TypeNs::Adt(it) => PathResolution::Def(it.into()),
             TypeNs::EnumVariant(it) => PathResolution::Def(it.into()),
             TypeNs::TypeAlias(it) => PathResolution::Def(it.into()),
@@ -233,16 +252,9 @@ impl SourceAnalyzer {
         });
         let values = self.resolver.resolve_path_in_value_ns_fully(db, &path).and_then(|val| {
             let res = match val {
-                ValueNs::LocalBinding(it) => {
-                    // We get a `PatId` from resolver, but it actually can only
-                    // point at `BindPat`, and not at the arbitrary pattern.
-                    let pat_ptr = self
-                        .body_source_map
-                        .as_ref()?
-                        .pat_syntax(it)?
-                        .ast // FIXME: ignoring file_id here is definitelly wrong
-                        .map_a(|ptr| ptr.cast::<ast::BindPat>().unwrap());
-                    PathResolution::LocalBinding(pat_ptr)
+                ValueNs::LocalBinding(pat_id) => {
+                    let var = Local { parent: self.body_owner?, pat_id };
+                    PathResolution::Local(var)
                 }
                 ValueNs::Function(it) => PathResolution::Def(it.into()),
                 ValueNs::Const(it) => PathResolution::Def(it.into()),
@@ -265,13 +277,13 @@ impl SourceAnalyzer {
 
     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())?;
+            let expr_id = self.expr_id(&path_expr.into())?;
             if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
                 return Some(PathResolution::AssocItem(assoc));
             }
         }
         if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
-            let pat_id = self.body_source_map.as_ref()?.node_pat(&path_pat.into())?;
+            let pat_id = self.pat_id(&path_pat.into())?;
             if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
                 return Some(PathResolution::AssocItem(assoc));
             }
@@ -286,7 +298,7 @@ impl SourceAnalyzer {
         let name = name_ref.as_name();
         let source_map = self.body_source_map.as_ref()?;
         let scopes = self.scopes.as_ref()?;
-        let scope = scope_for(scopes, source_map, name_ref.syntax());
+        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax());
         let ret = scopes
             .scope_chain(scope)
             .flat_map(|scope| scopes.entries(scope).iter())
@@ -419,11 +431,12 @@ impl SourceAnalyzer {
 fn scope_for(
     scopes: &ExprScopes,
     source_map: &BodySourceMap,
+    file_id: HirFileId,
     node: &SyntaxNode,
 ) -> Option<ScopeId> {
     node.ancestors()
         .filter_map(ast::Expr::cast)
-        .filter_map(|it| source_map.node_expr(&it))
+        .filter_map(|it| source_map.node_expr(Source { file_id, ast: &it }))
         .find_map(|it| scopes.scope_for(it))
 }