13 files changed, 294 insertions, 138 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 706d24c32..28002f740 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -313,7 +313,7 @@ pub struct StructField {
     pub(crate) id: StructFieldId,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum FieldSource {
     Named(ast::RecordFieldDef),
     Pos(ast::TupleFieldDef),
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
new file mode 100644
index 000000000..c6ad85fc7
--- /dev/null
+++ b/crates/ra_hir/src/from_source.rs
@@ -0,0 +1,211 @@
+use ra_db::{FileId, FilePosition};
+use ra_syntax::{
+    algo::find_node_at_offset,
+    ast::{self, AstNode, NameOwner},
+    SyntaxNode,
+};
+
+use crate::{
+    db::{AstDatabase, DefDatabase, HirDatabase},
+    ids::{AstItemDef, LocationCtx},
+    name::AsName,
+    Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
+    ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
+};
+
+pub trait FromSource: Sized {
+    type Ast;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self>;
+}
+
+impl FromSource for Struct {
+    type Ast = ast::StructDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Struct { id })
+    }
+}
+impl FromSource for Union {
+    type Ast = ast::StructDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Union { id })
+    }
+}
+impl FromSource for Enum {
+    type Ast = ast::EnumDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Enum { id })
+    }
+}
+impl FromSource for Trait {
+    type Ast = ast::TraitDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Trait { id })
+    }
+}
+impl FromSource for Function {
+    type Ast = ast::FnDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Function { id })
+    }
+}
+impl FromSource for Const {
+    type Ast = ast::ConstDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Const { id })
+    }
+}
+impl FromSource for Static {
+    type Ast = ast::StaticDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Static { id })
+    }
+}
+impl FromSource for TypeAlias {
+    type Ast = ast::TypeAliasDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(TypeAlias { id })
+    }
+}
+// FIXME: add impl FromSource for MacroDef
+
+impl FromSource for ImplBlock {
+    type Ast = ast::ImplBlock;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let module_src = crate::ModuleSource::from_child_node(
+            db,
+            src.file_id.original_file(db),
+            &src.ast.syntax(),
+        );
+        let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
+        let impls = module.impl_blocks(db);
+        impls.into_iter().find(|b| b.source(db) == src)
+    }
+}
+
+impl FromSource for EnumVariant {
+    type Ast = ast::EnumVariant;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let parent_enum = src.ast.parent_enum();
+        let src_enum = Source { file_id: src.file_id, ast: parent_enum };
+        let variants = Enum::from_source(db, src_enum)?.variants(db);
+        variants.into_iter().find(|v| v.source(db) == src)
+    }
+}
+
+impl FromSource for StructField {
+    type Ast = FieldSource;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let variant_def: VariantDef = match src.ast {
+            FieldSource::Named(ref field) => {
+                let ast = field.syntax().ancestors().find_map(ast::StructDef::cast)?;
+                let src = Source { file_id: src.file_id, ast };
+                let def = Struct::from_source(db, src)?;
+                VariantDef::from(def)
+            }
+            FieldSource::Pos(ref field) => {
+                let ast = field.syntax().ancestors().find_map(ast::EnumVariant::cast)?;
+                let src = Source { file_id: src.file_id, ast };
+                let def = EnumVariant::from_source(db, src)?;
+                VariantDef::from(def)
+            }
+        };
+        variant_def
+            .variant_data(db)
+            .fields()
+            .into_iter()
+            .flat_map(|it| it.iter())
+            .map(|(id, _)| StructField { parent: variant_def.clone(), id })
+            .find(|f| f.source(db) == src)
+    }
+}
+
+// FIXME: simplify it
+impl ModuleSource {
+    pub fn from_position(
+        db: &(impl DefDatabase + AstDatabase),
+        position: FilePosition,
+    ) -> ModuleSource {
+        let parse = db.parse(position.file_id);
+        match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
+            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
+            _ => {
+                let source_file = parse.tree().to_owned();
+                ModuleSource::SourceFile(source_file)
+            }
+        }
+    }
+
+    pub fn from_child_node(
+        db: &(impl DefDatabase + AstDatabase),
+        file_id: FileId,
+        child: &SyntaxNode,
+    ) -> ModuleSource {
+        if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
+            ModuleSource::Module(m.clone())
+        } else {
+            let source_file = db.parse(file_id).tree().to_owned();
+            ModuleSource::SourceFile(source_file)
+        }
+    }
+
+    pub fn from_file_id(db: &(impl DefDatabase + AstDatabase), file_id: FileId) -> ModuleSource {
+        let source_file = db.parse(file_id).tree().to_owned();
+        ModuleSource::SourceFile(source_file)
+    }
+}
+
+impl Module {
+    pub fn from_declaration(db: &impl HirDatabase, src: Source<ast::Module>) -> Option<Self> {
+        let src_parent = Source {
+            file_id: src.file_id,
+            ast: ModuleSource::new(db, Some(src.file_id.original_file(db)), None),
+        };
+        let parent_module = Module::from_definition(db, src_parent)?;
+        let child_name = src.ast.name()?;
+        parent_module.child(db, &child_name.as_name())
+    }
+
+    pub fn from_definition(
+        db: &(impl DefDatabase + AstDatabase),
+        src: Source<ModuleSource>,
+    ) -> Option<Self> {
+        let decl_id = match src.ast {
+            ModuleSource::Module(ref module) => {
+                assert!(!module.has_semi());
+                let ast_id_map = db.ast_id_map(src.file_id);
+                let item_id = ast_id_map.ast_id(module).with_file_id(src.file_id);
+                Some(item_id)
+            }
+            ModuleSource::SourceFile(_) => None,
+        };
+
+        let source_root_id = db.file_source_root(src.file_id.original_file(db));
+        db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
+            |krate| {
+                let def_map = db.crate_def_map(krate);
+                let module_id = def_map.find_module_by_source(src.file_id, decl_id)?;
+                Some(Module { krate, module_id })
+            },
+        )
+    }
+}
+
+fn from_source<N, DEF>(db: &(impl DefDatabase + AstDatabase), src: Source<N>) -> Option<DEF>
+where
+    N: AstNode,
+    DEF: AstItemDef<N>,
+{
+    let module_src =
+        crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
+    let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
+    let ctx = LocationCtx::new(db, module, src.file_id);
+    Some(DEF::from_ast(ctx, &src.ast))
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index e7a576aa0..a9de9fb6b 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -53,6 +53,8 @@ pub mod diagnostics;
 
 mod code_model;
 
+pub mod from_source;
+
 #[cfg(test)]
 mod marks;
 
@@ -67,6 +69,7 @@ pub use self::{
     adt::VariantDef,
     either::Either,
     expr::ExprScopes,
+    from_source::FromSource,
     generics::{GenericParam, GenericParams, HasGenericParams},
     ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
     impl_block::ImplBlock,
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 8dcea5071..cb405091e 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -93,7 +93,11 @@ impl MockDatabase {
         let mut files: Vec<FileId> = self.files.values().copied().collect();
         files.sort();
         for file in files {
-            let module = crate::source_binder::module_from_file_id(self, file).unwrap();
+            let src = crate::Source {
+                file_id: file.into(),
+                ast: crate::ModuleSource::new(self, Some(file), None),
+            };
+            let module = crate::Module::from_definition(self, src).unwrap();
             module.diagnostics(
                 self,
                 &mut DiagnosticSink::new(|d| {
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index bc721f6e0..c41862a0b 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -114,7 +114,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
     );
     {
         let events = db.log_executed(|| {
-            let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
+            let src = crate::Source {
+                file_id: pos.file_id.into(),
+                ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
+            };
+            let module = crate::Module::from_definition(&db, src).unwrap();
             let decls = module.declarations(&db);
             assert_eq!(decls.len(), 18);
         });
@@ -124,7 +128,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
 
     {
         let events = db.log_executed(|| {
-            let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
+            let src = crate::Source {
+                file_id: pos.file_id.into(),
+                ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
+            };
+            let module = crate::Module::from_definition(&db, src).unwrap();
             let decls = module.declarations(&db);
             assert_eq!(decls.len(), 18);
         });
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 4d895f0a1..296acc364 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -7,10 +7,9 @@
 /// purely for "IDE needs".
 use std::sync::Arc;
 
-use ra_db::{FileId, FilePosition};
+use ra_db::FileId;
 use ra_syntax::{
-    algo::find_node_at_offset,
-    ast::{self, AstNode, NameOwner},
+    ast::{self, AstNode},
     AstPtr,
     SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
@@ -28,119 +27,28 @@ use crate::{
     path::known,
     resolve::{ScopeDef, TypeNs, ValueNs},
     ty::method_resolution::implements_trait,
-    AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HasBody, HirFileId, MacroDef,
-    Module, Name, Path, Resolver, Static, Struct, Trait, Ty,
+    AsName, Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId, MacroDef,
+    Module, Name, Path, Resolver, Static, Struct, Ty,
 };
 
-/// Locates the module by `FileId`. Picks topmost module in the file.
-pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option<Module> {
-    module_from_source(db, file_id.into(), None)
-}
-
-/// Locates the child module by `mod child;` declaration.
-pub fn module_from_declaration(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    decl: ast::Module,
-) -> Option<Module> {
-    let parent_module = module_from_file_id(db, file_id);
-    let child_name = decl.name();
-    match (parent_module, child_name) {
-        (Some(parent_module), Some(child_name)) => parent_module.child(db, &child_name.as_name()),
-        _ => None,
-    }
-}
-
-/// Locates the module by position in the source code.
-pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
-    let parse = db.parse(position.file_id);
-    match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
-        Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m.clone()),
-        _ => module_from_file_id(db, position.file_id),
-    }
-}
-
-fn module_from_inline(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    module: ast::Module,
-) -> Option<Module> {
-    assert!(!module.has_semi());
-    let file_id = file_id.into();
-    let ast_id_map = db.ast_id_map(file_id);
-    let item_id = ast_id_map.ast_id(&module).with_file_id(file_id);
-    module_from_source(db, file_id, Some(item_id))
-}
-
-/// Locates the module by child syntax element within the module
-pub fn module_from_child_node(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    child: &SyntaxNode,
-) -> Option<Module> {
-    if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
-        module_from_inline(db, file_id, m)
-    } else {
-        module_from_file_id(db, file_id)
-    }
-}
-
-fn module_from_source(
-    db: &impl HirDatabase,
-    file_id: HirFileId,
-    decl_id: Option<AstId<ast::Module>>,
-) -> Option<Module> {
-    let source_root_id = db.file_source_root(file_id.as_original_file());
-    db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
-        |krate| {
-            let def_map = db.crate_def_map(krate);
-            let module_id = def_map.find_module_by_source(file_id, decl_id)?;
-            Some(Module { krate, module_id })
-        },
-    )
-}
-
-pub fn struct_from_module(
-    db: &impl HirDatabase,
-    module: Module,
-    struct_def: &ast::StructDef,
-) -> Struct {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Struct { id: ctx.to_def(struct_def) }
-}
-
-pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Enum { id: ctx.to_def(enum_def) }
-}
-
-pub fn trait_from_module(
-    db: &impl HirDatabase,
-    module: Module,
-    trait_def: &ast::TraitDef,
-) -> Trait {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Trait { id: ctx.to_def(trait_def) }
-}
-
 fn try_get_resolver_for_node(
     db: &impl HirDatabase,
     file_id: FileId,
     node: &SyntaxNode,
 ) -> Option<Resolver> {
     if let Some(module) = ast::Module::cast(node.clone()) {
-        Some(module_from_declaration(db, file_id, module)?.resolver(db))
-    } else if let Some(_) = ast::SourceFile::cast(node.clone()) {
-        Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+        let src = crate::Source { file_id: file_id.into(), ast: module };
+        Some(crate::Module::from_declaration(db, src)?.resolver(db))
+    } else if let Some(file) = ast::SourceFile::cast(node.clone()) {
+        let src =
+            crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(file) };
+        Some(crate::Module::from_definition(db, src)?.resolver(db))
     } else if let Some(s) = ast::StructDef::cast(node.clone()) {
-        let module = module_from_child_node(db, file_id, s.syntax())?;
-        Some(struct_from_module(db, module, &s).resolver(db))
+        let src = crate::Source { file_id: file_id.into(), ast: s };
+        Some(Struct::from_source(db, src)?.resolver(db))
     } else if let Some(e) = ast::EnumDef::cast(node.clone()) {
-        let module = module_from_child_node(db, file_id, e.syntax())?;
-        Some(enum_from_module(db, module, &e).resolver(db))
+        let src = crate::Source { file_id: file_id.into(), ast: e };
+        Some(Enum::from_source(db, src)?.resolver(db))
     } else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
         Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
     } else {
@@ -154,8 +62,10 @@ fn def_with_body_from_child_node(
     file_id: FileId,
     node: &SyntaxNode,
 ) -> Option<DefWithBody> {
-    let module = module_from_child_node(db, file_id, node)?;
+    let src = crate::ModuleSource::from_child_node(db, file_id, node);
+    let module = Module::from_definition(db, crate::Source { file_id: file_id.into(), ast: src })?;
     let ctx = LocationCtx::new(db, module, file_id.into());
+
     node.ancestors().find_map(|node| {
         if let Some(def) = ast::FnDef::cast(node.clone()) {
             return Some(Function { id: ctx.to_def(&def) }.into());
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 7139947b3..59bd3689b 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -1,4 +1,3 @@
-use hir::source_binder;
 use ra_syntax::{
     algo::{find_covering_element, find_node_at_offset},
     ast, AstNode, Parse, SourceFile,
@@ -47,7 +46,11 @@ impl<'a> CompletionContext<'a> {
         original_parse: &'a Parse<ast::SourceFile>,
         position: FilePosition,
     ) -> Option<CompletionContext<'a>> {
-        let module = source_binder::module_from_position(db, position);
+        let src = hir::ModuleSource::from_position(db, position);
+        let module = hir::Module::from_definition(
+            db,
+            hir::Source { file_id: position.file_id.into(), ast: src },
+        );
         let token =
             original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
         let analyzer =
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index c448aa8c5..1ae152e5b 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -1,9 +1,6 @@
 use std::cell::RefCell;
 
-use hir::{
-    diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
-    source_binder,
-};
+use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
 use itertools::Itertools;
 use ra_assists::ast_editor::{AstBuilder, AstEditor};
 use ra_db::SourceDatabase;
@@ -89,7 +86,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
             fix: Some(fix),
         })
     });
-    if let Some(m) = source_binder::module_from_file_id(db, file_id) {
+    let source_file = db.parse(file_id).tree().to_owned();
+    let src =
+        hir::Source { file_id: file_id.into(), ast: hir::ModuleSource::SourceFile(source_file) };
+    if let Some(m) = hir::Module::from_definition(db, src) {
         m.diagnostics(db, &mut sink);
     };
     drop(sink);
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 503dcacff..bc8863dad 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -96,9 +96,8 @@ pub(crate) fn name_definition(
 
     if let Some(module) = ast::Module::cast(parent.clone()) {
         if module.has_semi() {
-            if let Some(child_module) =
-                hir::source_binder::module_from_declaration(db, file_id, module)
-            {
+            let src = hir::Source { file_id: file_id.into(), ast: module };
+            if let Some(child_module) = hir::Module::from_declaration(db, src) {
                 let nav = NavigationTarget::from_module(db, child_module);
                 return Some(vec![nav]);
             }
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
index c5620dd52..f57f9a21b 100644
--- a/crates/ra_ide_api/src/impls.rs
+++ b/crates/ra_ide_api/src/impls.rs
@@ -1,4 +1,4 @@
-use hir::{db::HirDatabase, source_binder, ApplicationTy, Ty, TypeCtor};
+use hir::{db::HirDatabase, ApplicationTy, FromSource, Ty, TypeCtor};
 use ra_db::SourceDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
 
@@ -11,17 +11,21 @@ pub(crate) fn goto_implementation(
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
 
-    let module = source_binder::module_from_position(db, position)?;
+    let src = hir::ModuleSource::from_position(db, position);
+    let module = hir::Module::from_definition(
+        db,
+        hir::Source { file_id: position.file_id.into(), ast: src },
+    )?;
 
     if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             nominal_def.syntax().text_range(),
-            impls_for_def(db, &nominal_def, module)?,
+            impls_for_def(db, position, &nominal_def, module)?,
         ));
     } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             trait_def.syntax().text_range(),
-            impls_for_trait(db, &trait_def, module)?,
+            impls_for_trait(db, position, &trait_def, module)?,
         ));
     }
 
@@ -30,14 +34,19 @@ pub(crate) fn goto_implementation(
 
 fn impls_for_def(
     db: &RootDatabase,
+    position: FilePosition,
     node: &ast::NominalDef,
     module: hir::Module,
 ) -> Option<Vec<NavigationTarget>> {
     let ty = match node {
         ast::NominalDef::StructDef(def) => {
-            source_binder::struct_from_module(db, module, &def).ty(db)
+            let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
+            hir::Struct::from_source(db, src)?.ty(db)
+        }
+        ast::NominalDef::EnumDef(def) => {
+            let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
+            hir::Enum::from_source(db, src)?.ty(db)
         }
-        ast::NominalDef::EnumDef(def) => source_binder::enum_from_module(db, module, &def).ty(db),
     };
 
     let krate = module.krate(db)?;
@@ -54,10 +63,12 @@ fn impls_for_def(
 
 fn impls_for_trait(
     db: &RootDatabase,
+    position: FilePosition,
     node: &ast::TraitDef,
     module: hir::Module,
 ) -> Option<Vec<NavigationTarget>> {
-    let tr = source_binder::trait_from_module(db, module, node);
+    let src = hir::Source { file_id: position.file_id.into(), ast: node.clone() };
+    let tr = hir::Trait::from_source(db, src)?;
 
     let krate = module.krate(db)?;
     let impls = db.impls_in_crate(krate);
diff --git a/crates/ra_ide_api/src/parent_module.rs b/crates/ra_ide_api/src/parent_module.rs
index 7d5f9ea2c..3668da8d7 100644
--- a/crates/ra_ide_api/src/parent_module.rs
+++ b/crates/ra_ide_api/src/parent_module.rs
@@ -5,7 +5,11 @@ use crate::{db::RootDatabase, NavigationTarget};
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
 pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
-    let module = match hir::source_binder::module_from_position(db, position) {
+    let src = hir::ModuleSource::from_position(db, position);
+    let module = match hir::Module::from_definition(
+        db,
+        hir::Source { file_id: position.file_id.into(), ast: src },
+    ) {
         None => return Vec::new(),
         Some(it) => it,
     };
@@ -15,10 +19,12 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
 
 /// Returns `Vec` for the same reason as `parent_module`
 pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
-    let module = match hir::source_binder::module_from_file_id(db, file_id) {
-        Some(it) => it,
-        None => return Vec::new(),
-    };
+    let src = hir::ModuleSource::from_file_id(db, file_id);
+    let module =
+        match hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src }) {
+            Some(it) => it,
+            None => return Vec::new(),
+        };
     let krate = match module.krate(db) {
         Some(it) => it,
         None => return Vec::new(),
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 5f1f0efc3..acca71f2a 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -1,4 +1,4 @@
-use hir::{source_binder, Either, ModuleSource};
+use hir::{Either, ModuleSource};
 use ra_db::SourceDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode};
 use relative_path::{RelativePath, RelativePathBuf};
@@ -135,9 +135,8 @@ fn rename_mod(
 ) -> Option<SourceChange> {
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
-    if let Some(module) =
-        source_binder::module_from_declaration(db, position.file_id, ast_module.clone())
-    {
+    let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
+    if let Some(module) = hir::Module::from_declaration(db, module_src) {
         let src = module.definition_source(db);
         let file_id = src.file_id.as_original_file();
         match src.ast {
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 9d84b3d08..095ca56c4 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -63,7 +63,9 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
         return None;
     }
     let range = module.syntax().text_range();
-    let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax())?;
+    let src = hir::ModuleSource::from_child_node(db, file_id, &module.syntax());
+    let module =
+        hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src })?;
 
     let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
     Some(Runnable { range, kind: RunnableKind::TestMod { path } })