3 files changed, 132 insertions, 54 deletions

diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
index eaeef54c1..56bde3849 100644
--- a/crates/ra_analysis/src/descriptors/mod.rs
+++ b/crates/ra_analysis/src/descriptors/mod.rs
@@ -5,16 +5,16 @@ use std::sync::Arc;
 
 use ra_syntax::{
     ast::{self, AstNode, FnDefNode},
-    SmolStr, TextRange,
+    TextRange,
 };
 
 use crate::{
     db::SyntaxDatabase,
     descriptors::function::{resolve_local_name, FnId, FnScopes},
-    descriptors::module::{ModuleId, ModuleScope, ModuleTree},
+    descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
     input::SourceRootId,
     syntax_ptr::LocalSyntaxPtr,
-    Cancelable, FileId,
+    Cancelable,
 };
 
 salsa::query_group! {
@@ -23,7 +23,7 @@ salsa::query_group! {
             type ModuleTreeQuery;
             use fn module::imp::module_tree;
         }
-        fn submodules(file_id: FileId) -> Cancelable<Arc<Vec<SmolStr>>> {
+        fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
             type SubmodulesQuery;
             use fn module::imp::submodules;
         }
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs
index 3a010ecf5..b3b1f1f21 100644
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ b/crates/ra_analysis/src/descriptors/module/imp.rs
@@ -19,25 +19,66 @@ use super::{
     ModuleTree, Problem,
 };
 
+#[derive(Clone, Hash, PartialEq, Eq, Debug)]
+pub(crate) enum Submodule {
+    Declaration(SmolStr),
+    Definition(SmolStr, ModuleSource),
+}
+
+impl Submodule {
+    fn name(&self) -> &SmolStr {
+        match self {
+            Submodule::Declaration(name) => name,
+            Submodule::Definition(name, _) => name,
+        }
+    }
+}
+
 pub(crate) fn submodules(
     db: &impl DescriptorDatabase,
-    file_id: FileId,
-) -> Cancelable<Arc<Vec<SmolStr>>> {
+    source: ModuleSource,
+) -> Cancelable<Arc<Vec<Submodule>>> {
     db::check_canceled(db)?;
-    let file = db.file_syntax(file_id);
-    let root = file.ast();
-    let submodules = modules(root).map(|(name, _)| name).collect();
-    Ok(Arc::new(submodules))
+    let file_id = source.file_id();
+    let submodules = match source.resolve(db) {
+        ModuleSourceNode::Root(it) => collect_submodules(file_id, it.ast()),
+        ModuleSourceNode::Inline(it) => it
+            .ast()
+            .item_list()
+            .map(|it| collect_submodules(file_id, it))
+            .unwrap_or_else(Vec::new),
+    };
+    return Ok(Arc::new(submodules));
+
+    fn collect_submodules<'a>(
+        file_id: FileId,
+        root: impl ast::ModuleItemOwner<'a>,
+    ) -> Vec<Submodule> {
+        modules(root)
+            .map(|(name, m)| {
+                if m.has_semi() {
+                    Submodule::Declaration(name)
+                } else {
+                    let src = ModuleSource::new_inline(file_id, m);
+                    Submodule::Definition(name, src)
+                }
+            })
+            .collect()
+    }
 }
 
-pub(crate) fn modules(root: ast::Root<'_>) -> impl Iterator<Item = (SmolStr, ast::Module<'_>)> {
-    root.modules().filter_map(|module| {
-        let name = module.name()?.text();
-        if !module.has_semi() {
-            return None;
-        }
-        Some((name, module))
-    })
+pub(crate) fn modules<'a>(
+    root: impl ast::ModuleItemOwner<'a>,
+) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+    root.items()
+        .filter_map(|item| match item {
+            ast::ModuleItem::Module(m) => Some(m),
+            _ => None,
+        })
+        .filter_map(|module| {
+            let name = module.name()?.text();
+            Some((name, module))
+        })
 }
 
 pub(crate) fn module_scope(
@@ -66,11 +107,6 @@ pub(crate) fn module_tree(
     Ok(Arc::new(res))
 }
 
-#[derive(Clone, Hash, PartialEq, Eq, Debug)]
-pub struct Submodule {
-    pub name: SmolStr,
-}
-
 fn create_module_tree<'a>(
     db: &impl DescriptorDatabase,
     source_root: SourceRootId,
@@ -85,7 +121,8 @@ fn create_module_tree<'a>(
 
     let source_root = db.source_root(source_root);
     for &file_id in source_root.files.iter() {
-        if visited.contains(&file_id) {
+        let source = ModuleSource::File(file_id);
+        if visited.contains(&source) {
             continue; // TODO: use explicit crate_roots here
         }
         assert!(!roots.contains_key(&file_id));
@@ -96,7 +133,7 @@ fn create_module_tree<'a>(
             &mut visited,
             &mut roots,
             None,
-            file_id,
+            source,
         )?;
         roots.insert(file_id, module_id);
     }
@@ -107,36 +144,63 @@ fn build_subtree(
     db: &impl DescriptorDatabase,
     source_root: &SourceRoot,
     tree: &mut ModuleTree,
-    visited: &mut FxHashSet<FileId>,
+    visited: &mut FxHashSet<ModuleSource>,
     roots: &mut FxHashMap<FileId, ModuleId>,
     parent: Option<LinkId>,
-    file_id: FileId,
+    source: ModuleSource,
 ) -> Cancelable<ModuleId> {
-    visited.insert(file_id);
+    visited.insert(source);
     let id = tree.push_mod(ModuleData {
-        source: ModuleSource::File(file_id),
+        source,
         parent,
         children: Vec::new(),
     });
-    for name in db.submodules(file_id)?.iter() {
-        let (points_to, problem) = resolve_submodule(file_id, name, &source_root.file_resolver);
+    for sub in db.submodules(source)?.iter() {
         let link = tree.push_link(LinkData {
-            name: name.clone(),
+            name: sub.name().clone(),
             owner: id,
             points_to: Vec::new(),
             problem: None,
         });
 
-        let points_to = points_to
-            .into_iter()
-            .map(|file_id| match roots.remove(&file_id) {
-                Some(module_id) => {
-                    tree.module_mut(module_id).parent = Some(link);
-                    Ok(module_id)
-                }
-                None => build_subtree(db, source_root, tree, visited, roots, Some(link), file_id),
-            })
-            .collect::<Cancelable<Vec<_>>>()?;
+        let (points_to, problem) = match sub {
+            Submodule::Declaration(name) => {
+                let (points_to, problem) =
+                    resolve_submodule(source, &name, &source_root.file_resolver);
+                let points_to = points_to
+                    .into_iter()
+                    .map(|file_id| match roots.remove(&file_id) {
+                        Some(module_id) => {
+                            tree.module_mut(module_id).parent = Some(link);
+                            Ok(module_id)
+                        }
+                        None => build_subtree(
+                            db,
+                            source_root,
+                            tree,
+                            visited,
+                            roots,
+                            Some(link),
+                            ModuleSource::File(file_id),
+                        ),
+                    })
+                    .collect::<Cancelable<Vec<_>>>()?;
+                (points_to, problem)
+            }
+            Submodule::Definition(_name, submodule_source) => {
+                let points_to = build_subtree(
+                    db,
+                    source_root,
+                    tree,
+                    visited,
+                    roots,
+                    Some(link),
+                    *submodule_source,
+                )?;
+                (vec![points_to], None)
+            }
+        };
+
         tree.link_mut(link).points_to = points_to;
         tree.link_mut(link).problem = problem;
     }
@@ -144,10 +208,17 @@ fn build_subtree(
 }
 
 fn resolve_submodule(
-    file_id: FileId,
+    source: ModuleSource,
     name: &SmolStr,
     file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
+    let file_id = match source {
+        ModuleSource::File(it) => it,
+        ModuleSource::Inline(..) => {
+            // TODO
+            return (Vec::new(), None);
+        }
+    };
     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_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
index e22489fc1..3d799ba05 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -25,17 +25,17 @@ pub(crate) struct ModuleTree {
 }
 
 impl ModuleTree {
-    pub(crate) fn modules_for_file(&self, file_id: FileId) -> Vec<ModuleId> {
+    pub(crate) fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
         self.mods
             .iter()
             .enumerate()
-            .filter(|(_idx, it)| it.source.is_file(file_id))
+            .filter(|(_idx, it)| it.source == source)
             .map(|(idx, _)| ModuleId(idx as u32))
             .collect()
     }
 
-    pub(crate) fn any_module_for_file(&self, file_id: FileId) -> Option<ModuleId> {
-        self.modules_for_file(file_id).pop()
+    pub(crate) fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
+        self.modules_for_source(source).pop()
     }
 }
 
@@ -142,9 +142,7 @@ impl LinkId {
                     .1;
                 ast.into()
             }
-            ModuleSourceNode::Inline(..) => {
-                unimplemented!("https://github.com/rust-analyzer/rust-analyzer/issues/181")
-            }
+            ModuleSourceNode::Inline(it) => it,
         }
     }
 }
@@ -157,6 +155,12 @@ struct ModuleData {
 }
 
 impl ModuleSource {
+    pub(crate) fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
+        assert!(!module.has_semi());
+        let ptr = SyntaxPtr::new(file_id, module.syntax());
+        ModuleSource::Inline(ptr)
+    }
+
     pub(crate) fn as_file(self) -> Option<FileId> {
         match self {
             ModuleSource::File(f) => Some(f),
@@ -164,6 +168,13 @@ impl ModuleSource {
         }
     }
 
+    pub(crate) fn file_id(self) -> FileId {
+        match self {
+            ModuleSource::File(f) => f,
+            ModuleSource::Inline(ptr) => ptr.file_id(),
+        }
+    }
+
     fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
         match self {
             ModuleSource::File(file_id) => {
@@ -178,10 +189,6 @@ impl ModuleSource {
             }
         }
     }
-
-    fn is_file(self, file_id: FileId) -> bool {
-        self.as_file() == Some(file_id)
-    }
 }
 
 #[derive(Hash, Debug, PartialEq, Eq)]