Refactor primary IDE API

This introduces the new type -- Semantics.
Semantics maps SyntaxNodes to various semantic info, such as type,
name resolution or macro expansions.

To do so, Semantics maintains a HashMap which maps every node it saw
to the file from which the node originated. This is enough to get all
the necessary hir bits just from syntax.

2 files changed, 27 insertions, 31 deletions

diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 478e18871..91b21429a 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,34 +1,32 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{InFile, PathResolution, SourceBinder};
+use hir::{PathResolution, Semantics};
+use ra_ide_db::defs::NameDefinition;
+use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
 
-use super::NameDefinition;
-use ra_ide_db::RootDatabase;
-
-pub use ra_ide_db::defs::{classify_name, from_module_def, from_struct_field};
+pub use ra_ide_db::defs::{from_module_def, from_struct_field};
 
 pub(crate) fn classify_name_ref(
-    sb: &mut SourceBinder<RootDatabase>,
-    name_ref: InFile<&ast::NameRef>,
+    sema: &Semantics<RootDatabase>,
+    name_ref: &ast::NameRef,
 ) -> Option<NameDefinition> {
     let _p = profile("classify_name_ref");
 
-    let parent = name_ref.value.syntax().parent()?;
-    let analyzer = sb.analyze(name_ref.map(|it| it.syntax()), None);
+    let parent = name_ref.syntax().parent()?;
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
-        if let Some(func) = analyzer.resolve_method_call(&method_call) {
+        if let Some(func) = sema.resolve_method_call(&method_call) {
             return Some(from_module_def(func.into()));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_fields);
-        if let Some(field) = analyzer.resolve_field(&field_expr) {
+        if let Some(field) = sema.resolve_field(&field_expr) {
             return Some(from_struct_field(field));
         }
     }
@@ -36,22 +34,20 @@ pub(crate) fn classify_name_ref(
     if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
         tested_by!(goto_def_for_record_fields);
         tested_by!(goto_def_for_field_init_shorthand);
-        if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
+        if let Some(field_def) = sema.resolve_record_field(&record_field) {
             return Some(from_struct_field(field_def));
         }
     }
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
         tested_by!(goto_def_for_macros);
-        if let Some(macro_def) =
-            analyzer.resolve_macro_call(sb.db, name_ref.with_value(&macro_call))
-        {
+        if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
             return Some(NameDefinition::Macro(macro_def));
         }
     }
 
-    let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
-    let resolved = analyzer.resolve_path(sb.db, &path)?;
+    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
+    let resolved = sema.resolve_path(&path)?;
     let res = match resolved {
         PathResolution::Def(def) => from_module_def(def),
         PathResolution::AssocItem(item) => {
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index bdb90020b..5b4bcf434 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
-use hir::ModuleSource;
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt};
+use hir::{ModuleSource, Semantics};
+use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
@@ -24,15 +24,16 @@ pub(crate) fn rename(
         _ => return None,
     }
 
-    let parse = db.parse(position.file_id);
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
     if let Some((ast_name, ast_module)) =
-        find_name_and_module_at_offset(parse.tree().syntax(), position)
+        find_name_and_module_at_offset(source_file.syntax(), position)
     {
         let range = ast_name.syntax().text_range();
-        rename_mod(db, &ast_name, &ast_module, position, new_name)
+        rename_mod(&sema, &ast_name, &ast_module, position, new_name)
             .map(|info| RangeInfo::new(range, info))
     } else {
-        rename_reference(db, position, new_name)
+        rename_reference(sema.db, position, new_name)
     }
 }
 
@@ -54,7 +55,7 @@ fn source_edit_from_file_id_range(
 }
 
 fn rename_mod(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
     ast_name: &ast::Name,
     ast_module: &ast::Module,
     position: FilePosition,
@@ -62,13 +63,12 @@ fn rename_mod(
 ) -> Option<SourceChange> {
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
-    let module_src = hir::InFile { file_id: position.file_id.into(), value: ast_module.clone() };
-    if let Some(module) = hir::SourceBinder::new(db).to_def(module_src) {
-        let src = module.definition_source(db);
-        let file_id = src.file_id.original_file(db);
+    if let Some(module) = sema.to_def(ast_module) {
+        let src = module.definition_source(sema.db);
+        let file_id = src.file_id.original_file(sema.db);
         match src.value {
             ModuleSource::SourceFile(..) => {
-                let mod_path: RelativePathBuf = db.file_relative_path(file_id);
+                let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
                 // mod is defined in path/to/dir/mod.rs
                 let dst_path = if mod_path.file_stem() == Some("mod") {
                     mod_path
@@ -82,7 +82,7 @@ fn rename_mod(
                 if let Some(path) = dst_path {
                     let move_file = FileSystemEdit::MoveFile {
                         src: file_id,
-                        dst_source_root: db.file_source_root(position.file_id),
+                        dst_source_root: sema.db.file_source_root(position.file_id),
                         dst_path: path,
                     };
                     file_system_edits.push(move_file);
@@ -98,7 +98,7 @@ fn rename_mod(
     };
     source_file_edits.push(edit);
 
-    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(db, position, None) {
+    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(sema.db, position, None) {
         let ref_edits = refs.references.into_iter().map(|reference| {
             source_edit_from_file_id_range(
                 reference.file_range.file_id,