9 files changed, 216 insertions, 212 deletions

diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 2f01bae6d..ff41fd326 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -7,10 +7,11 @@ use ra_syntax::{
 use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, FileId, Cancelable};
 
 use crate::{
-    DefLoc, DefId, FnId,
+    DefLoc, DefId,
     SourceFileItems, SourceItemId,
     query_definitions,
     FnScopes,
+    function::FnId,
     module::{ModuleId, ModuleTree, ModuleSource,
     nameres::{ItemMap, InputModuleItems}},
 };
@@ -19,7 +20,6 @@ salsa::query_group! {
 
 pub trait HirDatabase: SyntaxDatabase
     + AsRef<LocationIntener<DefLoc, DefId>>
-    + AsRef<LocationIntener<SourceItemId, FnId>>
 {
     fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
         type FnScopesQuery;
diff --git a/crates/ra_hir/src/function/mod.rs b/crates/ra_hir/src/function/mod.rs
index c8af2e54f..5187dc051 100644
--- a/crates/ra_hir/src/function/mod.rs
+++ b/crates/ra_hir/src/function/mod.rs
@@ -6,66 +6,27 @@ use std::{
 };
 
 use ra_syntax::{
-    TextRange, TextUnit, SyntaxNodeRef,
+    TextRange, TextUnit,
     ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
-use ra_db::FileId;
 
-use crate::{
-    FnId, HirDatabase, SourceItemId,
-};
+use crate::{ DefId, HirDatabase };
 
 pub use self::scope::FnScopes;
 
-impl FnId {
-    pub fn get(db: &impl HirDatabase, file_id: FileId, fn_def: ast::FnDef) -> FnId {
-        let file_items = db.file_items(file_id);
-        let item_id = file_items.id_of(fn_def.syntax());
-        let item_id = SourceItemId { file_id, item_id };
-        FnId::from_loc(db, &item_id)
-    }
-}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct FnId(pub(crate) DefId);
 
 pub struct Function {
     fn_id: FnId,
 }
 
 impl Function {
-    pub fn guess_from_source(
-        db: &impl HirDatabase,
-        file_id: FileId,
-        fn_def: ast::FnDef,
-    ) -> Function {
-        let fn_id = FnId::get(db, file_id, fn_def);
+    pub(crate) fn new(def_id: DefId) -> Function {
+        let fn_id = FnId(def_id);
         Function { fn_id }
     }
 
-    pub fn guess_for_name_ref(
-        db: &impl HirDatabase,
-        file_id: FileId,
-        name_ref: ast::NameRef,
-    ) -> Option<Function> {
-        Function::guess_for_node(db, file_id, name_ref.syntax())
-    }
-
-    pub fn guess_for_bind_pat(
-        db: &impl HirDatabase,
-        file_id: FileId,
-        bind_pat: ast::BindPat,
-    ) -> Option<Function> {
-        Function::guess_for_node(db, file_id, bind_pat.syntax())
-    }
-
-    fn guess_for_node(
-        db: &impl HirDatabase,
-        file_id: FileId,
-        node: SyntaxNodeRef,
-    ) -> Option<Function> {
-        let fn_def = node.ancestors().find_map(ast::FnDef::cast)?;
-        let res = Function::guess_from_source(db, file_id, fn_def);
-        Some(res)
-    }
-
     pub fn scope(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
         db.fn_scopes(self.fn_id)
     }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index e7b6a81f4..983ce99cb 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -22,6 +22,7 @@ mod function;
 mod module;
 mod path;
 mod arena;
+pub mod source_binder;
 
 use std::ops::Index;
 
@@ -41,63 +42,58 @@ pub use self::{
 
 pub use self::function::FnSignatureInfo;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct FnId(u32);
-ra_db::impl_numeric_id!(FnId);
-
-impl FnId {
-    pub fn from_loc(
-        db: &impl AsRef<LocationIntener<SourceItemId, FnId>>,
-        loc: &SourceItemId,
-    ) -> FnId {
-        db.as_ref().loc2id(loc)
-    }
-    pub fn loc(self, db: &impl AsRef<LocationIntener<SourceItemId, FnId>>) -> SourceItemId {
-        db.as_ref().id2loc(self)
-    }
-}
-
+/// Def's are a core concept of hir. A `Def` is an Item (function, module, etc)
+/// in a specific module.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct DefId(u32);
 ra_db::impl_numeric_id!(DefId);
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) enum DefKind {
+    Module,
+    Function,
+    Item,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum DefLoc {
-    Module {
-        id: ModuleId,
-        source_root: SourceRootId,
-    },
-    Item {
-        source_item_id: SourceItemId,
-    },
+pub struct DefLoc {
+    pub(crate) kind: DefKind,
+    source_root_id: SourceRootId,
+    module_id: ModuleId,
+    source_item_id: SourceItemId,
 }
 
 impl DefId {
-    pub fn loc(self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefLoc {
+    pub(crate) fn loc(self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefLoc {
         db.as_ref().id2loc(self)
     }
 }
 
 impl DefLoc {
-    pub fn id(&self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefId {
+    pub(crate) fn id(&self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefId {
         db.as_ref().loc2id(&self)
     }
 }
 
 pub enum Def {
     Module(Module),
+    Function(Function),
     Item,
 }
 
 impl DefId {
     pub fn resolve(self, db: &impl HirDatabase) -> Cancelable<Def> {
         let loc = self.loc(db);
-        let res = match loc {
-            DefLoc::Module { id, source_root } => {
-                let descr = Module::new(db, source_root, id)?;
-                Def::Module(descr)
+        let res = match loc.kind {
+            DefKind::Module => {
+                let module = Module::new(db, loc.source_root_id, loc.module_id)?;
+                Def::Module(module)
             }
-            DefLoc::Item { .. } => Def::Item,
+            DefKind::Function => {
+                let function = Function::new(self);
+                Def::Function(function)
+            }
+            DefKind::Item => Def::Item,
         };
         Ok(res)
     }
@@ -131,6 +127,10 @@ impl SourceFileItems {
             .unwrap();
         id
     }
+    pub fn id_of_source_file(&self) -> SourceFileItemId {
+        let (id, _syntax) = self.arena.iter().next().unwrap();
+        id
+    }
 }
 
 impl Index<SourceFileItemId> for SourceFileItems {
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 8e256b89f..e855df11d 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -6,7 +6,7 @@ use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId,
 use relative_path::RelativePathBuf;
 use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
 
-use crate::{db, DefId, DefLoc, FnId, SourceItemId};
+use crate::{db, DefId, DefLoc};
 
 #[derive(Debug)]
 pub(crate) struct MockDatabase {
@@ -65,7 +65,6 @@ impl MockDatabase {
 
 #[derive(Debug, Default)]
 struct IdMaps {
-    fns: LocationIntener<SourceItemId, FnId>,
     defs: LocationIntener<DefLoc, DefId>,
 }
 
@@ -117,12 +116,6 @@ impl AsRef<LocationIntener<DefLoc, DefId>> for MockDatabase {
     }
 }
 
-impl AsRef<LocationIntener<SourceItemId, FnId>> for MockDatabase {
-    fn as_ref(&self) -> &LocationIntener<SourceItemId, FnId> {
-        &self.id_maps.fns
-    }
-}
-
 impl MockDatabase {
     pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<MockDatabase>> {
         *self.events.lock() = Some(Vec::new());
diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index 76ea129a7..0eec38797 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -66,7 +66,7 @@ fn create_module_tree<'a>(
 
     let source_root = db.source_root(source_root);
     for &file_id in source_root.files.iter() {
-        let source = ModuleSource::SourceFile(file_id);
+        let source = ModuleSource::new_file(db, file_id);
         if visited.contains(&source) {
             continue; // TODO: use explicit crate_roots here
         }
@@ -126,7 +126,7 @@ fn build_subtree(
                             visited,
                             roots,
                             Some(link),
-                            ModuleSource::SourceFile(file_id),
+                            ModuleSource::new_file(db, file_id),
                         ),
                     })
                     .collect::<Cancelable<Vec<_>>>()?;
@@ -157,13 +157,8 @@ fn resolve_submodule(
     name: &SmolStr,
     file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
-    let file_id = match source {
-        ModuleSource::SourceFile(it) => it,
-        ModuleSource::Module(..) => {
-            // TODO
-            return (Vec::new(), None);
-        }
-    };
+    // TODO: handle submodules of inline modules properly
+    let file_id = source.file_id();
     let mod_name = file_resolver.file_stem(file_id);
     let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
 
diff --git a/crates/ra_hir/src/module/mod.rs b/crates/ra_hir/src/module/mod.rs
index 3ae83d8cb..580c737c3 100644
--- a/crates/ra_hir/src/module/mod.rs
+++ b/crates/ra_hir/src/module/mod.rs
@@ -3,18 +3,16 @@ pub(super) mod nameres;
 
 use std::sync::Arc;
 
-use ra_editor::find_node_at_offset;
-
 use ra_syntax::{
     algo::generate,
     ast::{self, AstNode, NameOwner},
     SmolStr, SyntaxNode,
 };
-use ra_db::{SourceRootId, FileId, FilePosition, Cancelable};
+use ra_db::{SourceRootId, FileId, Cancelable};
 use relative_path::RelativePathBuf;
 
 use crate::{
-    DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId,
+    DefKind, DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId,
     arena::{Arena, Id},
 };
 
@@ -25,56 +23,11 @@ pub use self::nameres::ModuleScope;
 #[derive(Debug, Clone)]
 pub struct Module {
     tree: Arc<ModuleTree>,
-    source_root_id: SourceRootId,
-    module_id: ModuleId,
+    pub(crate) source_root_id: SourceRootId,
+    pub(crate) module_id: ModuleId,
 }
 
 impl Module {
-    /// Lookup `Module` by `FileId`. Note that this is inherently
-    /// lossy transformation: in general, a single source might correspond to
-    /// several modules.
-    pub fn guess_from_file_id(
-        db: &impl HirDatabase,
-        file_id: FileId,
-    ) -> Cancelable<Option<Module>> {
-        Module::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
-    }
-
-    /// Lookup `Module` by position in the source code. Note that this
-    /// is inherently lossy transformation: in general, a single source might
-    /// correspond to several modules.
-    pub fn guess_from_position(
-        db: &impl HirDatabase,
-        position: FilePosition,
-    ) -> Cancelable<Option<Module>> {
-        let file = db.source_file(position.file_id);
-        let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
-        {
-            Some(m) if !m.has_semi() => ModuleSource::new_inline(db, position.file_id, m),
-            _ => ModuleSource::SourceFile(position.file_id),
-        };
-        Module::guess_from_source(db, position.file_id, module_source)
-    }
-
-    fn guess_from_source(
-        db: &impl HirDatabase,
-        file_id: FileId,
-        module_source: ModuleSource,
-    ) -> Cancelable<Option<Module>> {
-        let source_root_id = db.file_source_root(file_id);
-        let module_tree = db.module_tree(source_root_id)?;
-
-        let res = match module_tree.any_module_for_source(module_source) {
-            None => None,
-            Some(module_id) => Some(Module {
-                tree: module_tree,
-                source_root_id,
-                module_id,
-            }),
-        };
-        Ok(res)
-    }
-
     pub(super) fn new(
         db: &impl HirDatabase,
         source_root_id: SourceRootId,
@@ -127,9 +80,11 @@ impl Module {
     }
 
     pub fn def_id(&self, db: &impl HirDatabase) -> DefId {
-        let def_loc = DefLoc::Module {
-            id: self.module_id,
-            source_root: self.source_root_id,
+        let def_loc = DefLoc {
+            kind: DefKind::Module,
+            source_root_id: self.source_root_id,
+            module_id: self.module_id,
+            source_item_id: self.module_id.source(&self.tree).0,
         };
         def_loc.id(db)
     }
@@ -161,7 +116,12 @@ impl Module {
         let segments = path.segments;
         for name in segments.iter() {
             let module = match curr.loc(db) {
-                DefLoc::Module { id, source_root } => Module::new(db, source_root, id)?,
+                DefLoc {
+                    kind: DefKind::Module,
+                    source_root_id,
+                    module_id,
+                    ..
+                } => Module::new(db, source_root_id, module_id)?,
                 _ => return Ok(None),
             };
             let scope = module.scope(db)?;
@@ -193,26 +153,17 @@ impl ModuleTree {
         self.mods.iter().map(|(id, _)| id)
     }
 
-    fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
-        self.mods
-            .iter()
-            .filter(|(_idx, it)| it.source == source)
-            .map(|(idx, _)| idx)
-            .collect()
-    }
-
-    fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
-        self.modules_for_source(source).pop()
+    pub(crate) fn modules_with_sources<'a>(
+        &'a self,
+    ) -> impl Iterator<Item = (ModuleId, ModuleSource)> + 'a {
+        self.mods.iter().map(|(id, m)| (id, m.source))
     }
 }
 
 /// `ModuleSource` is the syntax tree element that produced this module:
 /// either a file, or an inlinde module.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum ModuleSource {
-    SourceFile(FileId),
-    Module(SourceItemId),
-}
+pub struct ModuleSource(SourceItemId);
 
 /// An owned syntax node for a module. Unlike `ModuleSource`,
 /// this holds onto the AST for the whole file.
@@ -310,45 +261,41 @@ pub struct ModuleData {
 }
 
 impl ModuleSource {
+    // precondition: item_id **must** point to module
+    fn new(file_id: FileId, item_id: SourceFileItemId) -> ModuleSource {
+        let source_item_id = SourceItemId { file_id, item_id };
+        ModuleSource(source_item_id)
+    }
+
+    pub(crate) fn new_file(db: &impl HirDatabase, file_id: FileId) -> ModuleSource {
+        let file_items = db.file_items(file_id);
+        let item_id = file_items.id_of_source_file();
+        ModuleSource::new(file_id, item_id)
+    }
+
     pub(crate) fn new_inline(
         db: &impl HirDatabase,
         file_id: FileId,
-        module: ast::Module,
+        m: ast::Module,
     ) -> ModuleSource {
-        assert!(!module.has_semi());
-        let items = db.file_items(file_id);
-        let item_id = items.id_of(module.syntax());
-        let id = SourceItemId { file_id, item_id };
-        ModuleSource::Module(id)
-    }
-
-    pub fn as_file(self) -> Option<FileId> {
-        match self {
-            ModuleSource::SourceFile(f) => Some(f),
-            ModuleSource::Module(..) => None,
-        }
+        assert!(!m.has_semi());
+        let file_items = db.file_items(file_id);
+        let item_id = file_items.id_of(m.syntax());
+        ModuleSource::new(file_id, item_id)
     }
 
     pub fn file_id(self) -> FileId {
-        match self {
-            ModuleSource::SourceFile(f) => f,
-            ModuleSource::Module(source_item_id) => source_item_id.file_id,
-        }
+        self.0.file_id
     }
 
     pub(crate) fn resolve(self, db: &impl HirDatabase) -> ModuleSourceNode {
-        match self {
-            ModuleSource::SourceFile(file_id) => {
-                let syntax = db.source_file(file_id);
-                ModuleSourceNode::SourceFile(syntax.ast().owned())
-            }
-            ModuleSource::Module(item_id) => {
-                let syntax = db.file_item(item_id);
-                let syntax = syntax.borrowed();
-                let module = ast::Module::cast(syntax).unwrap();
-                ModuleSourceNode::Module(module.owned())
-            }
+        let syntax_node = db.file_item(self.0);
+        let syntax_node = syntax_node.borrowed();
+        if let Some(file) = ast::SourceFile::cast(syntax_node) {
+            return ModuleSourceNode::SourceFile(file.owned());
         }
+        let module = ast::Module::cast(syntax_node).unwrap();
+        ModuleSourceNode::Module(module.owned())
     }
 }
 
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 8529e16b3..61a1acfe6 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -28,7 +28,7 @@ use ra_db::SourceRootId;
 
 use crate::{
     Cancelable, FileId,
-    DefId, DefLoc,
+    DefId, DefLoc, DefKind,
     SourceItemId, SourceFileItemId, SourceFileItems,
     Path, PathKind,
     HirDatabase,
@@ -247,7 +247,10 @@ where
                 // handle submodules separatelly
                 continue;
             }
-            let def_loc = DefLoc::Item {
+            let def_loc = DefLoc {
+                kind: DefKind::Item,
+                source_root_id: self.source_root,
+                module_id,
                 source_item_id: SourceItemId {
                     file_id,
                     item_id: item.id,
@@ -261,10 +264,12 @@ where
             module_items.items.insert(item.name.clone(), resolution);
         }
 
-        for (name, mod_id) in module_id.children(&self.module_tree) {
-            let def_loc = DefLoc::Module {
-                id: mod_id,
-                source_root: self.source_root,
+        for (name, module_id) in module_id.children(&self.module_tree) {
+            let def_loc = DefLoc {
+                kind: DefKind::Module,
+                source_root_id: self.source_root,
+                module_id,
+                source_item_id: module_id.source(&self.module_tree).0,
             };
             let def_id = def_loc.id(self.db);
             let resolution = Resolution {
@@ -316,7 +321,11 @@ where
 
             if !is_last {
                 curr = match def_id.loc(self.db) {
-                    DefLoc::Module { id, .. } => id,
+                    DefLoc {
+                        kind: DefKind::Module,
+                        module_id,
+                        ..
+                    } => module_id,
                     _ => return,
                 }
             } else {
@@ -354,7 +363,9 @@ mod tests {
     fn item_map(fixture: &str) -> (Arc<hir::ItemMap>, hir::ModuleId) {
         let (db, pos) = MockDatabase::with_position(fixture);
         let source_root = db.file_source_root(pos.file_id);
-        let module = hir::Module::guess_from_position(&db, pos).unwrap().unwrap();
+        let module = hir::source_binder::module_from_position(&db, pos)
+            .unwrap()
+            .unwrap();
         let module_id = module.module_id;
         (db.item_map(source_root).unwrap(), module_id)
     }
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index 6f602878c..e4d721601 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -11,21 +11,21 @@ use ra_syntax::{
 use ra_db::{SourceRootId, FileId, Cancelable,};
 
 use crate::{
-        FnId,
-        SourceFileItems, SourceItemId,
-        db::HirDatabase,
-        function::FnScopes,
-        module::{
-            ModuleSource, ModuleSourceNode, ModuleId,
-            imp::Submodule,
-            nameres::{InputModuleItems, ItemMap, Resolver},
-        },
+    SourceFileItems, SourceItemId, DefKind,
+    db::HirDatabase,
+    function::{FnScopes, FnId},
+    module::{
+        ModuleSource, ModuleSourceNode, ModuleId,
+        imp::Submodule,
+        nameres::{InputModuleItems, ItemMap, Resolver},
+    },
 };
 
 /// Resolve `FnId` to the corresponding `SyntaxNode`
 pub(super) fn fn_syntax(db: &impl HirDatabase, fn_id: FnId) -> FnDefNode {
-    let item_id = fn_id.loc(db);
-    let syntax = db.file_item(item_id);
+    let def_loc = fn_id.0.loc(db);
+    assert!(def_loc.kind == DefKind::Function);
+    let syntax = db.file_item(def_loc.source_item_id);
     FnDef::cast(syntax.borrowed()).unwrap().owned()
 }
 
@@ -36,9 +36,10 @@ pub(super) fn fn_scopes(db: &impl HirDatabase, fn_id: FnId) -> Arc<FnScopes> {
 }
 
 pub(super) fn file_items(db: &impl HirDatabase, file_id: FileId) -> Arc<SourceFileItems> {
+    let mut res = SourceFileItems::default();
     let source_file = db.source_file(file_id);
+    res.alloc(source_file.syntax().owned());
     let source_file = source_file.borrowed();
-    let mut res = SourceFileItems::default();
     source_file
         .syntax()
         .descendants()
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
new file mode 100644
index 000000000..479155805
--- /dev/null
+++ b/crates/ra_hir/src/source_binder.rs
@@ -0,0 +1,96 @@
+/// Lookup hir elements using position in the source code. This is a lossy
+/// transformation: in general, a single source might correspond to several
+/// modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
+/// modules.
+///
+/// So, this modules should not be used during hir construction, it exists
+/// purely for "IDE needs".
+use ra_db::{FileId, FilePosition, Cancelable};
+use ra_editor::find_node_at_offset;
+use ra_syntax::{
+    ast::{self, AstNode},
+    SyntaxNodeRef,
+};
+
+use crate::{
+    HirDatabase, Module, Function, SourceItemId,
+    module::ModuleSource,
+    DefKind, DefLoc
+};
+
+/// Locates the module by `FileId`. Picks topmost module in the file.
+pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable<Option<Module>> {
+    let module_source = ModuleSource::new_file(db, file_id);
+    module_from_source(db, module_source)
+}
+
+/// Locates the module by position in the source code.
+pub fn module_from_position(
+    db: &impl HirDatabase,
+    position: FilePosition,
+) -> Cancelable<Option<Module>> {
+    let file = db.source_file(position.file_id);
+    let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset) {
+        Some(m) if !m.has_semi() => ModuleSource::new_inline(db, position.file_id, m),
+        _ => ModuleSource::new_file(db, position.file_id),
+    };
+    module_from_source(db, module_source)
+}
+
+/// Locates the module by child syntax element within the module
+pub fn module_from_child_node(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    child: SyntaxNodeRef,
+) -> Cancelable<Option<Module>> {
+    let module_source = if let Some(m) = child
+        .ancestors()
+        .filter_map(ast::Module::cast)
+        .find(|it| !it.has_semi())
+    {
+        ModuleSource::new_inline(db, file_id, m)
+    } else {
+        ModuleSource::new_file(db, file_id)
+    };
+    module_from_source(db, module_source)
+}
+
+fn module_from_source(
+    db: &impl HirDatabase,
+    module_source: ModuleSource,
+) -> Cancelable<Option<Module>> {
+    let source_root_id = db.file_source_root(module_source.file_id());
+    let module_tree = db.module_tree(source_root_id)?;
+    let m = module_tree
+        .modules_with_sources()
+        .find(|(_id, src)| src == &module_source);
+    let module_id = ctry!(m).0;
+    Ok(Some(Module::new(db, source_root_id, module_id)?))
+}
+
+pub fn function_from_source(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    fn_def: ast::FnDef,
+) -> Cancelable<Option<Function>> {
+    let module = ctry!(module_from_child_node(db, file_id, fn_def.syntax())?);
+    let file_items = db.file_items(file_id);
+    let item_id = file_items.id_of(fn_def.syntax());
+    let source_item_id = SourceItemId { file_id, item_id };
+    let def_loc = DefLoc {
+        kind: DefKind::Function,
+        source_root_id: module.source_root_id,
+        module_id: module.module_id,
+        source_item_id,
+    };
+    Ok(Some(Function::new(def_loc.id(db))))
+}
+
+pub fn function_from_child_node(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    node: SyntaxNodeRef,
+) -> Cancelable<Option<Function>> {
+    let fn_def = ctry!(node.ancestors().find_map(ast::FnDef::cast));
+    function_from_source(db, file_id, fn_def)
+}