3 files changed, 53 insertions, 57 deletions

diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 3483a7176..46cba30a3 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,6 +1,6 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{FromSource, InFile, Module, ModuleSource, PathResolution, SourceAnalyzer};
+use hir::{InFile, PathResolution, SourceBinder};
 use ra_prof::profile;
 use ra_syntax::{ast, match_ast, AstNode};
 use test_utils::tested_by;
@@ -11,7 +11,10 @@ use super::{
 };
 use crate::db::RootDatabase;
 
-pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Option<NameDefinition> {
+pub(crate) fn classify_name(
+    sb: &mut SourceBinder<RootDatabase>,
+    name: InFile<&ast::Name>,
+) -> Option<NameDefinition> {
     let _p = profile("classify_name");
     let parent = name.value.syntax().parent()?;
 
@@ -19,90 +22,79 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
         match parent {
             ast::BindPat(it) => {
                 let src = name.with_value(it);
-                let local = hir::Local::from_source(db, src)?;
+                let local = sb.to_def(src)?;
                 Some(NameDefinition {
                     visibility: None,
-                    container: local.module(db),
+                    container: local.module(sb.db),
                     kind: NameKind::Local(local),
                 })
             },
             ast::RecordFieldDef(it) => {
-                let ast = hir::FieldSource::Named(it);
-                let src = name.with_value(ast);
-                let field = hir::StructField::from_source(db, src)?;
-                Some(from_struct_field(db, field))
+                let src = name.with_value(it);
+                let field: hir::StructField = sb.to_def(src)?;
+                Some(from_struct_field(sb.db, field))
             },
             ast::Module(it) => {
-                let def = {
-                    if !it.has_semi() {
-                        let ast = hir::ModuleSource::Module(it);
-                        let src = name.with_value(ast);
-                        hir::Module::from_definition(db, src)
-                    } else {
-                        let src = name.with_value(it);
-                        hir::Module::from_declaration(db, src)
-                    }
-                }?;
-                Some(from_module_def(db, def.into(), None))
+                let def = sb.to_def(name.with_value(it))?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::StructDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Struct::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Struct = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::EnumDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Enum::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Enum = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::TraitDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Trait::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Trait = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::StaticDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Static::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Static = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::EnumVariant(it) => {
                 let src = name.with_value(it);
-                let def = hir::EnumVariant::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::EnumVariant = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::FnDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Function::from_source(db, src)?;
+                let def: hir::Function = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::ConstDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Const::from_source(db, src)?;
+                let def: hir::Const = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::TypeAliasDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::TypeAlias::from_source(db, src)?;
+                let def: hir::TypeAlias = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::MacroCall(it) => {
                 let src = name.with_value(it);
-                let def = hir::MacroDef::from_source(db, src.clone())?;
+                let def = sb.to_def(src.clone())?;
 
-                let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-                let module = Module::from_definition(db, src.with_value(module_src))?;
+                let module = sb.to_module_def(src.file_id.original_file(sb.db))?;
 
                 Some(NameDefinition {
                     visibility: None,
@@ -112,10 +104,10 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
             },
             ast::TypeParam(it) => {
                 let src = name.with_value(it);
-                let def = hir::TypeParam::from_source(db, src)?;
+                let def = sb.to_def(src)?;
                 Some(NameDefinition {
                     visibility: None,
-                    container: def.module(db),
+                    container: def.module(sb.db),
                     kind: NameKind::TypeParam(def),
                 })
             },
@@ -125,25 +117,25 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
 }
 
 pub(crate) fn classify_name_ref(
-    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
     name_ref: InFile<&ast::NameRef>,
 ) -> Option<NameDefinition> {
     let _p = profile("classify_name_ref");
 
     let parent = name_ref.value.syntax().parent()?;
-    let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
+    let analyzer = sb.analyze(name_ref.map(|it| it.syntax()), None);
 
     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) {
-            return Some(from_assoc_item(db, func.into()));
+            return Some(from_assoc_item(sb.db, 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) {
-            return Some(from_struct_field(db, field));
+            return Some(from_struct_field(sb.db, field));
         }
     }
 
@@ -151,35 +143,37 @@ pub(crate) fn classify_name_ref(
         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) {
-            return Some(from_struct_field(db, field_def));
+            return Some(from_struct_field(sb.db, field_def));
         }
     }
 
-    let ast = ModuleSource::from_child_node(db, name_ref.with_value(&parent));
     // FIXME: find correct container and visibility for each case
-    let container = Module::from_definition(db, name_ref.with_value(ast))?;
     let visibility = None;
+    let container = sb.to_module_def(name_ref.file_id.original_file(sb.db))?;
 
     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(db, name_ref.with_value(&macro_call)) {
+        if let Some(macro_def) =
+            analyzer.resolve_macro_call(sb.db, name_ref.with_value(&macro_call))
+        {
             let kind = NameKind::Macro(macro_def);
             return Some(NameDefinition { kind, container, visibility });
         }
     }
 
     let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
-    let resolved = analyzer.resolve_path(db, &path)?;
+    let resolved = analyzer.resolve_path(sb.db, &path)?;
     match resolved {
-        PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
-        PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)),
+        PathResolution::Def(def) => Some(from_module_def(sb.db, def, Some(container))),
+        PathResolution::AssocItem(item) => Some(from_assoc_item(sb.db, item)),
         PathResolution::Local(local) => {
-            let container = local.module(db);
             let kind = NameKind::Local(local);
+            let container = local.module(sb.db);
             Some(NameDefinition { kind, container, visibility: None })
         }
         PathResolution::TypeParam(par) => {
             let kind = NameKind::TypeParam(par);
+            let container = par.module(sb.db);
             Some(NameDefinition { kind, container, visibility })
         }
         PathResolution::Macro(def) => {
@@ -188,7 +182,7 @@ pub(crate) fn classify_name_ref(
         }
         PathResolution::SelfType(impl_block) => {
             let kind = NameKind::SelfType(impl_block);
-            let container = impl_block.module(db);
+            let container = impl_block.module(sb.db);
             Some(NameDefinition { kind, container, visibility })
         }
     }
diff --git a/crates/ra_ide/src/references/name_definition.rs b/crates/ra_ide/src/references/name_definition.rs
index 8c67c8863..1e4226ab9 100644
--- a/crates/ra_ide/src/references/name_definition.rs
+++ b/crates/ra_ide/src/references/name_definition.rs
@@ -25,6 +25,8 @@ pub enum NameKind {
 #[derive(PartialEq, Eq)]
 pub(crate) struct NameDefinition {
     pub visibility: Option<ast::Visibility>,
+    /// FIXME: this doesn't really make sense. For example, builtin types don't
+    /// really have a module.
     pub container: Module,
     pub kind: NameKind,
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index e02985dcd..626efb603 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -63,7 +63,7 @@ fn rename_mod(
     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::Module::from_declaration(db, module_src) {
+    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);
         match src.value {