3 files changed, 82 insertions, 61 deletions

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..11e6e8e75 100644
--- a/crates/ra_hir/src/module/mod.rs
+++ b/crates/ra_hir/src/module/mod.rs
@@ -8,13 +8,13 @@ use ra_editor::find_node_at_offset;
 use ra_syntax::{
     algo::generate,
     ast::{self, AstNode, NameOwner},
-    SmolStr, SyntaxNode,
+    SmolStr, SyntaxNode, SyntaxNodeRef,
 };
 use ra_db::{SourceRootId, FileId, FilePosition, 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,8 +25,8 @@ 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 {
@@ -37,7 +37,8 @@ impl Module {
         db: &impl HirDatabase,
         file_id: FileId,
     ) -> Cancelable<Option<Module>> {
-        Module::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
+        let module_source = ModuleSource::new_file(db, file_id);
+        Module::guess_from_source(db, module_source)
     }
 
     /// Lookup `Module` by position in the source code. Note that this
@@ -51,17 +52,33 @@ impl Module {
         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),
+            _ => ModuleSource::new_file(db, position.file_id),
         };
-        Module::guess_from_source(db, position.file_id, module_source)
+        Module::guess_from_source(db, module_source)
     }
 
-    fn guess_from_source(
+    pub fn guess_from_child_node(
         db: &impl HirDatabase,
         file_id: FileId,
+        node: SyntaxNodeRef,
+    ) -> Cancelable<Option<Module>> {
+        let module_source = if let Some(m) = node
+            .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::guess_from_source(db, module_source)
+    }
+
+    fn guess_from_source(
+        db: &impl HirDatabase,
         module_source: ModuleSource,
     ) -> Cancelable<Option<Module>> {
-        let source_root_id = db.file_source_root(file_id);
+        let source_root_id = db.file_source_root(module_source.file_id());
         let module_tree = db.module_tree(source_root_id)?;
 
         let res = match module_tree.any_module_for_source(module_source) {
@@ -127,9 +144,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 +180,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)?;
@@ -209,10 +233,7 @@ impl ModuleTree {
 /// `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 +331,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..c2b380a80 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 {