4 files changed, 106 insertions, 63 deletions

diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index ee409e34e..7b285d280 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -11,30 +11,17 @@ doctest = false
 wasm = []
 
 [dependencies]
-either = "1.5.3"
-format-buf = "1.0.0"
-indexmap = "1.3.2"
-itertools = "0.8.2"
-join_to_string = "0.1.3"
 log = "0.4.8"
 rayon = "1.3.0"
 fst = { version = "0.3.5", default-features = false }
 rustc-hash = "1.1.0"
-unicase = "2.6.0"
 superslice = "1.0.0"
-once_cell = "1.3.1"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_db = { path = "../ra_db" }
-ra_cfg = { path = "../ra_cfg" }
-ra_fmt = { path = "../ra_fmt" }
 ra_prof = { path = "../ra_prof" }
-test_utils = { path = "../test_utils" }
 
 # ra_ide should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
 hir = { path = "../ra_hir", package = "ra_hir" }
-
-[dev-dependencies]
-insta = "0.13.1"
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 04c214624..93f32ba85 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    Adt, FieldSource, HasSource, ImplBlock, InFile, Local, MacroDef, Module, ModuleDef,
-    SourceBinder, StructField, TypeParam,
+    Adt, FieldSource, HasSource, ImplBlock, Local, MacroDef, Module, ModuleDef, Semantics,
+    StructField, TypeParam,
 };
 use ra_prof::profile;
 use ra_syntax::{
@@ -68,78 +68,97 @@ impl NameDefinition {
     }
 }
 
-pub fn classify_name(
-    sb: &mut SourceBinder<RootDatabase>,
-    name: InFile<&ast::Name>,
-) -> Option<NameDefinition> {
+pub enum NameClass {
+    NameDefinition(NameDefinition),
+    /// `None` in `if let None = Some(82) {}`
+    ConstReference(NameDefinition),
+}
+
+impl NameClass {
+    pub fn into_definition(self) -> Option<NameDefinition> {
+        match self {
+            NameClass::NameDefinition(it) => Some(it),
+            NameClass::ConstReference(_) => None,
+        }
+    }
+
+    pub fn definition(self) -> NameDefinition {
+        match self {
+            NameClass::NameDefinition(it) | NameClass::ConstReference(it) => it,
+        }
+    }
+}
+
+pub fn classify_name(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameClass> {
+    if let Some(bind_pat) = name.syntax().parent().and_then(ast::BindPat::cast) {
+        if let Some(def) = sema.resolve_bind_pat_to_const(&bind_pat) {
+            return Some(NameClass::ConstReference(NameDefinition::ModuleDef(def)));
+        }
+    }
+
+    classify_name_inner(sema, name).map(NameClass::NameDefinition)
+}
+
+fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameDefinition> {
     let _p = profile("classify_name");
-    let parent = name.value.syntax().parent()?;
+    let parent = name.syntax().parent()?;
 
     match_ast! {
         match parent {
             ast::BindPat(it) => {
-                let src = name.with_value(it);
-                let local = sb.to_def(src)?;
+                let local = sema.to_def(&it)?;
                 Some(NameDefinition::Local(local))
             },
             ast::RecordFieldDef(it) => {
-                let src = name.with_value(it);
-                let field: hir::StructField = sb.to_def(src)?;
+                let field: hir::StructField = sema.to_def(&it)?;
                 Some(from_struct_field(field))
             },
             ast::Module(it) => {
-                let def = sb.to_def(name.with_value(it))?;
+                let def = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::StructDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Struct = sb.to_def(src)?;
+                let def: hir::Struct = sema.to_def(&it)?;
+                Some(from_module_def(def.into()))
+            },
+            ast::UnionDef(it) => {
+                let def: hir::Union = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::EnumDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Enum = sb.to_def(src)?;
+                let def: hir::Enum = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::TraitDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Trait = sb.to_def(src)?;
+                let def: hir::Trait = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::StaticDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Static = sb.to_def(src)?;
+                let def: hir::Static = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::EnumVariant(it) => {
-                let src = name.with_value(it);
-                let def: hir::EnumVariant = sb.to_def(src)?;
+                let def: hir::EnumVariant = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::FnDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Function = sb.to_def(src)?;
+                let def: hir::Function = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::ConstDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::Const = sb.to_def(src)?;
+                let def: hir::Const = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::TypeAliasDef(it) => {
-                let src = name.with_value(it);
-                let def: hir::TypeAlias = sb.to_def(src)?;
+                let def: hir::TypeAlias = sema.to_def(&it)?;
                 Some(from_module_def(def.into()))
             },
             ast::MacroCall(it) => {
-                let src = name.with_value(it);
-                let def = sb.to_def(src.clone())?;
-
+                let def = sema.to_def(&it)?;
                 Some(NameDefinition::Macro(def))
             },
             ast::TypeParam(it) => {
-                let src = name.with_value(it);
-                let def = sb.to_def(src)?;
+                let def = sema.to_def(&it)?;
                 Some(NameDefinition::TypeParam(def))
             },
             _ => None,
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index b8dd358a9..e5fc3c470 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the ra_assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
 
-use hir::{db::HirDatabase, ModuleDef, SourceBinder};
+use hir::{ModuleDef, Semantics};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
 
@@ -12,17 +12,17 @@ use crate::{
 };
 
 pub struct ImportsLocator<'a> {
-    source_binder: SourceBinder<'a, RootDatabase>,
+    sema: Semantics<'a, RootDatabase>,
 }
 
 impl<'a> ImportsLocator<'a> {
     pub fn new(db: &'a RootDatabase) -> Self {
-        Self { source_binder: SourceBinder::new(db) }
+        Self { sema: Semantics::new(db) }
     }
 
     pub fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
         let _p = profile("search_for_imports");
-        let db = self.source_binder.db;
+        let db = self.sema.db;
 
         let project_results = {
             let mut query = Query::new(name_to_import.to_string());
@@ -41,7 +41,7 @@ impl<'a> ImportsLocator<'a> {
         project_results
             .into_iter()
             .chain(lib_results.into_iter())
-            .filter_map(|import_candidate| self.get_name_definition(db, &import_candidate))
+            .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
             .filter_map(|name_definition_to_import| match name_definition_to_import {
                 NameDefinition::ModuleDef(module_def) => Some(module_def),
                 _ => None,
@@ -49,22 +49,17 @@ impl<'a> ImportsLocator<'a> {
             .collect()
     }
 
-    fn get_name_definition(
-        &mut self,
-        db: &impl HirDatabase,
-        import_candidate: &FileSymbol,
-    ) -> Option<NameDefinition> {
+    fn get_name_definition(&mut self, import_candidate: &FileSymbol) -> Option<NameDefinition> {
         let _p = profile("get_name_definition");
-        let file_id = import_candidate.file_id.into();
-        let candidate_node = import_candidate.ptr.to_node(&db.parse_or_expand(file_id)?);
+        let file_id = import_candidate.file_id;
+
+        let candidate_node = import_candidate.ptr.to_node(self.sema.parse(file_id).syntax());
         let candidate_name_node = if candidate_node.kind() != NAME {
             candidate_node.children().find(|it| it.kind() == NAME)?
         } else {
             candidate_node
         };
-        classify_name(
-            &mut self.source_binder,
-            hir::InFile { file_id, value: &ast::Name::cast(candidate_name_node)? },
-        )
+        let name = ast::Name::cast(candidate_name_node)?;
+        classify_name(&self.sema, &name)?.into_definition()
     }
 }
diff --git a/crates/ra_ide_db/src/line_index.rs b/crates/ra_ide_db/src/line_index.rs
index af7b759e5..b9db5c276 100644
--- a/crates/ra_ide_db/src/line_index.rs
+++ b/crates/ra_ide_db/src/line_index.rs
@@ -1,7 +1,8 @@
 //! `LineIndex` maps flat `TextUnit` offsets into `(Line, Column)`
 //! representation.
+use std::iter;
 
-use ra_syntax::TextUnit;
+use ra_syntax::{TextRange, TextUnit};
 use rustc_hash::FxHashMap;
 use superslice::Ext;
 
@@ -87,6 +88,19 @@ impl LineIndex {
         self.newlines[line_col.line as usize] + col
     }
 
+    pub fn lines(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
+        let lo = self.newlines.lower_bound(&range.start());
+        let hi = self.newlines.upper_bound(&range.end());
+        let all = iter::once(range.start())
+            .chain(self.newlines[lo..hi].iter().copied())
+            .chain(iter::once(range.end()));
+
+        all.clone()
+            .zip(all.skip(1))
+            .map(|(lo, hi)| TextRange::from_to(lo, hi))
+            .filter(|it| !it.is_empty())
+    }
+
     fn utf8_to_utf16_col(&self, line: u32, mut col: TextUnit) -> usize {
         if let Some(utf16_chars) = self.utf16_lines.get(&line) {
             let mut correction = TextUnit::from_usize(0);
@@ -221,4 +235,32 @@ const C: char = \"メ メ\";
 
         assert_eq!(col_index.utf16_to_utf8_col(2, 15), TextUnit::from_usize(15));
     }
+
+    #[test]
+    fn test_splitlines() {
+        fn r(lo: u32, hi: u32) -> TextRange {
+            TextRange::from_to(lo.into(), hi.into())
+        }
+
+        let text = "a\nbb\nccc\n";
+        let line_index = LineIndex::new(text);
+
+        let actual = line_index.lines(r(0, 9)).collect::<Vec<_>>();
+        let expected = vec![r(0, 2), r(2, 5), r(5, 9)];
+        assert_eq!(actual, expected);
+
+        let text = "";
+        let line_index = LineIndex::new(text);
+
+        let actual = line_index.lines(r(0, 0)).collect::<Vec<_>>();
+        let expected = vec![];
+        assert_eq!(actual, expected);
+
+        let text = "\n";
+        let line_index = LineIndex::new(text);
+
+        let actual = line_index.lines(r(0, 1)).collect::<Vec<_>>();
+        let expected = vec![r(0, 1)];
+        assert_eq!(actual, expected)
+    }
 }