2 files changed, 5 insertions, 208 deletions

diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 899e0fa04..e4598eec0 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -42,192 +42,3 @@ pub(crate) fn resolver_for_scope(
     }
     r
 }
-
-#[cfg(test)]
-mod tests {
-    use hir_expand::Source;
-    use ra_db::{fixture::WithFixture, SourceDatabase};
-    use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
-    use test_utils::{assert_eq_text, extract_offset};
-
-    use crate::{source_binder::SourceAnalyzer, test_db::TestDB};
-
-    fn do_check(code: &str, expected: &[&str]) {
-        let (off, code) = extract_offset(code);
-        let code = {
-            let mut buf = String::new();
-            let off = u32::from(off) as usize;
-            buf.push_str(&code[..off]);
-            buf.push_str("marker");
-            buf.push_str(&code[off..]);
-            buf
-        };
-
-        let (db, file_id) = TestDB::with_single_file(&code);
-
-        let file = db.parse(file_id).ok().unwrap();
-        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
-        let analyzer = SourceAnalyzer::new(&db, file_id, marker.syntax(), None);
-
-        let scopes = analyzer.scopes();
-        let expr_id = analyzer
-            .body_source_map()
-            .node_expr(Source { file_id: file_id.into(), ast: &marker.into() })
-            .unwrap();
-        let scope = scopes.scope_for(expr_id);
-
-        let actual = scopes
-            .scope_chain(scope)
-            .flat_map(|scope| scopes.entries(scope))
-            .map(|it| it.name().to_string())
-            .collect::<Vec<_>>()
-            .join("\n");
-        let expected = expected.join("\n");
-        assert_eq_text!(&expected, &actual);
-    }
-
-    #[test]
-    fn test_lambda_scope() {
-        do_check(
-            r"
-            fn quux(foo: i32) {
-                let f = |bar, baz: i32| {
-                    <|>
-                };
-            }",
-            &["bar", "baz", "foo"],
-        );
-    }
-
-    #[test]
-    fn test_call_scope() {
-        do_check(
-            r"
-            fn quux() {
-                f(|x| <|> );
-            }",
-            &["x"],
-        );
-    }
-
-    #[test]
-    fn test_method_call_scope() {
-        do_check(
-            r"
-            fn quux() {
-                z.f(|x| <|> );
-            }",
-            &["x"],
-        );
-    }
-
-    #[test]
-    fn test_loop_scope() {
-        do_check(
-            r"
-            fn quux() {
-                loop {
-                    let x = ();
-                    <|>
-                };
-            }",
-            &["x"],
-        );
-    }
-
-    #[test]
-    fn test_match() {
-        do_check(
-            r"
-            fn quux() {
-                match () {
-                    Some(x) => {
-                        <|>
-                    }
-                };
-            }",
-            &["x"],
-        );
-    }
-
-    #[test]
-    fn test_shadow_variable() {
-        do_check(
-            r"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }",
-            &["x"],
-        );
-    }
-
-    fn do_check_local_name(code: &str, expected_offset: u32) {
-        let (off, code) = extract_offset(code);
-
-        let (db, file_id) = TestDB::with_single_file(&code);
-        let file = db.parse(file_id).ok().unwrap();
-        let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
-            .expect("failed to find a name at the target offset");
-        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
-        let analyzer = SourceAnalyzer::new(&db, file_id, name_ref.syntax(), None);
-
-        let local_name_entry = analyzer.resolve_local_name(&name_ref).unwrap();
-        let local_name =
-            local_name_entry.ptr().either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
-        assert_eq!(local_name.range(), expected_name.syntax().text_range());
-    }
-
-    #[test]
-    fn test_resolve_local_name() {
-        do_check_local_name(
-            r#"
-            fn foo(x: i32, y: u32) {
-                {
-                    let z = x * 2;
-                }
-                {
-                    let t = x<|> * 3;
-                }
-            }"#,
-            21,
-        );
-    }
-
-    #[test]
-    fn test_resolve_local_name_declaration() {
-        do_check_local_name(
-            r#"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }"#,
-            21,
-        );
-    }
-
-    #[test]
-    fn test_resolve_local_name_shadow() {
-        do_check_local_name(
-            r"
-            fn foo(x: String) {
-                let x : &str = &x;
-                x<|>
-            }
-            ",
-            53,
-        );
-    }
-
-    #[test]
-    fn ref_patterns_contribute_bindings() {
-        do_check_local_name(
-            r"
-            fn foo() {
-                if let Some(&from) = bar() {
-                    from<|>;
-                }
-            }
-            ",
-            53,
-        );
-    }
-}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index c1ecf18b9..662d3f880 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -19,7 +19,6 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
 };
-use rustc_hash::FxHashSet;
 
 use crate::{
     db::HirDatabase,
@@ -286,22 +285,14 @@ impl SourceAnalyzer {
     }
 
     fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
-        let mut shadowed = FxHashSet::default();
         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, self.file_id.into(), name_ref.syntax());
-        let ret = scopes
-            .scope_chain(scope)
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .filter(|entry| entry.name() == &name)
-            .nth(0);
-        ret.and_then(|entry| {
-            Some(ScopeEntryWithSyntax {
-                name: entry.name().clone(),
-                ptr: source_map.pat_syntax(entry.pat())?.ast,
-            })
+        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax())?;
+        let entry = scopes.resolve_name_in_scope(scope, &name)?;
+        Some(ScopeEntryWithSyntax {
+            name: entry.name().clone(),
+            ptr: source_map.pat_syntax(entry.pat())?.ast,
         })
     }
 
@@ -413,11 +404,6 @@ impl SourceAnalyzer {
     pub(crate) fn inference_result(&self) -> Arc<crate::ty::InferenceResult> {
         self.infer.clone().unwrap()
     }
-
-    #[cfg(test)]
-    pub(crate) fn scopes(&self) -> Arc<ExprScopes> {
-        self.scopes.clone().unwrap()
-    }
 }
 
 fn scope_for(