7 files changed, 262 insertions, 354 deletions

diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index cef2dc9d2..b5fe16bfa 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -7,14 +7,13 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
+    attr::Attr,
     db::DefDatabase,
     ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind},
     name::MACRO_RULES,
     nameres::{
-        diagnostics::DefDiagnostic,
-        mod_resolution::{resolve_submodule, ParentModule},
-        raw, Crate, CrateDefMap, CrateModuleId, ModuleData, ModuleDef, PerNs, ReachedFixedPoint,
-        Resolution, ResolveMode,
+        diagnostics::DefDiagnostic, mod_resolution::ModDir, raw, Crate, CrateDefMap, CrateModuleId,
+        ModuleData, ModuleDef, PerNs, ReachedFixedPoint, Resolution, ResolveMode,
     },
     Adt, AstId, Const, Enum, Function, HirFileId, MacroDef, Module, Name, Path, PathKind, Static,
     Struct, Trait, TypeAlias, Union,
@@ -45,6 +44,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
         glob_imports: FxHashMap::default(),
         unresolved_imports: Vec::new(),
         unexpanded_macros: Vec::new(),
+        mod_dirs: FxHashMap::default(),
         macro_stack_monitor: MacroStackMonitor::default(),
         cfg_options,
     };
@@ -87,6 +87,7 @@ struct DefCollector<'a, DB> {
     glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
     unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
     unexpanded_macros: Vec<(CrateModuleId, AstId<ast::MacroCall>, Path)>,
+    mod_dirs: FxHashMap<CrateModuleId, ModDir>,
 
     /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
     /// To prevent stack overflow, we add a deep counter here for prevent that.
@@ -107,11 +108,10 @@ where
         self.def_map.modules[module_id].definition = Some(file_id);
         ModCollector {
             def_collector: &mut *self,
-            attr_path: None,
             module_id,
             file_id: file_id.into(),
             raw_items: &raw_items,
-            parent_module: None,
+            mod_dir: ModDir::root(),
         }
         .collect(raw_items.items());
 
@@ -481,13 +481,13 @@ where
         if !self.macro_stack_monitor.is_poison(macro_def_id) {
             let file_id: HirFileId = macro_call_id.as_file(MacroFileKind::Items);
             let raw_items = self.db.raw_items(file_id);
+            let mod_dir = self.mod_dirs[&module_id].clone();
             ModCollector {
                 def_collector: &mut *self,
                 file_id,
-                attr_path: None,
                 module_id,
                 raw_items: &raw_items,
-                parent_module: None,
+                mod_dir,
             }
             .collect(raw_items.items());
         } else {
@@ -508,9 +508,8 @@ struct ModCollector<'a, D> {
     def_collector: D,
     module_id: CrateModuleId,
     file_id: HirFileId,
-    attr_path: Option<&'a SmolStr>,
     raw_items: &'a raw::RawItems,
-    parent_module: Option<ParentModule<'a>>,
+    mod_dir: ModDir,
 }
 
 impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
@@ -518,6 +517,10 @@ where
     DB: DefDatabase,
 {
     fn collect(&mut self, items: &[raw::RawItem]) {
+        // Note: don't assert that inserted value is fresh: it's simply not true
+        // for macros.
+        self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone());
+
         // Prelude module is always considered to be `#[macro_use]`.
         if let Some(prelude_module) = self.def_collector.def_map.prelude {
             if prelude_module.krate != self.def_collector.def_map.krate {
@@ -530,7 +533,7 @@ where
         // `#[macro_use] extern crate` is hoisted to imports macros before collecting
         // any other items.
         for item in items {
-            if self.is_cfg_enabled(&item.attrs) {
+            if self.is_cfg_enabled(item.attrs()) {
                 if let raw::RawItemKind::Import(import_id) = item.kind {
                     let import = self.raw_items[import_id].clone();
                     if import.is_extern_crate && import.is_macro_use {
@@ -541,9 +544,11 @@ where
         }
 
         for item in items {
-            if self.is_cfg_enabled(&item.attrs) {
+            if self.is_cfg_enabled(item.attrs()) {
                 match item.kind {
-                    raw::RawItemKind::Module(m) => self.collect_module(&self.raw_items[m]),
+                    raw::RawItemKind::Module(m) => {
+                        self.collect_module(&self.raw_items[m], item.attrs())
+                    }
                     raw::RawItemKind::Import(import_id) => self
                         .def_collector
                         .unresolved_imports
@@ -555,53 +560,48 @@ where
         }
     }
 
-    fn collect_module(&mut self, module: &raw::ModuleData) {
+    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &[Attr]) {
+        let path_attr = self.path_attr(attrs);
+        let is_macro_use = self.is_macro_use(attrs);
         match module {
             // inline module, just recurse
-            raw::ModuleData::Definition { name, items, ast_id, attr_path, is_macro_use } => {
+            raw::ModuleData::Definition { name, items, ast_id } => {
                 let module_id =
                     self.push_child_module(name.clone(), ast_id.with_file_id(self.file_id), None);
-                let parent_module = ParentModule { name, attr_path: attr_path.as_ref() };
 
                 ModCollector {
                     def_collector: &mut *self.def_collector,
                     module_id,
-                    attr_path: attr_path.as_ref(),
                     file_id: self.file_id,
                     raw_items: self.raw_items,
-                    parent_module: Some(parent_module),
+                    mod_dir: self.mod_dir.descend_into_definition(name, path_attr),
                 }
                 .collect(&*items);
-                if *is_macro_use {
+                if is_macro_use {
                     self.import_all_legacy_macros(module_id);
                 }
             }
             // out of line module, resolve, parse and recurse
-            raw::ModuleData::Declaration { name, ast_id, attr_path, is_macro_use } => {
+            raw::ModuleData::Declaration { name, ast_id } => {
                 let ast_id = ast_id.with_file_id(self.file_id);
-                let is_root = self.def_collector.def_map.modules[self.module_id].parent.is_none();
-                match resolve_submodule(
+                match self.mod_dir.resolve_declaration(
                     self.def_collector.db,
                     self.file_id,
-                    self.attr_path,
                     name,
-                    is_root,
-                    attr_path.as_ref(),
-                    self.parent_module,
+                    path_attr,
                 ) {
-                    Ok(file_id) => {
+                    Ok((file_id, mod_dir)) => {
                         let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
                         let raw_items = self.def_collector.db.raw_items(file_id.into());
                         ModCollector {
                             def_collector: &mut *self.def_collector,
                             module_id,
-                            attr_path: attr_path.as_ref(),
                             file_id: file_id.into(),
                             raw_items: &raw_items,
-                            parent_module: None,
+                            mod_dir,
                         }
                         .collect(raw_items.items());
-                        if *is_macro_use {
+                        if is_macro_use {
                             self.import_all_legacy_macros(module_id);
                         }
                     }
@@ -714,12 +714,16 @@ where
         }
     }
 
-    fn is_cfg_enabled(&self, attrs: &raw::Attrs) -> bool {
-        attrs.as_ref().map_or(true, |attrs| {
-            attrs
-                .iter()
-                .all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
-        })
+    fn is_cfg_enabled(&self, attrs: &[Attr]) -> bool {
+        attrs.iter().all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
+    }
+
+    fn path_attr<'a>(&self, attrs: &'a [Attr]) -> Option<&'a SmolStr> {
+        attrs.iter().find_map(|attr| attr.as_path())
+    }
+
+    fn is_macro_use<'a>(&self, attrs: &'a [Attr]) -> bool {
+        attrs.iter().any(|attr| attr.is_simple_atom("macro_use"))
     }
 }
 
@@ -747,6 +751,7 @@ mod tests {
             glob_imports: FxHashMap::default(),
             unresolved_imports: Vec::new(),
             unexpanded_macros: Vec::new(),
+            mod_dirs: FxHashMap::default(),
             macro_stack_monitor: monitor,
             cfg_options: &CfgOptions::default(),
         };
diff --git a/crates/ra_hir/src/nameres/mod_resolution.rs b/crates/ra_hir/src/nameres/mod_resolution.rs
index 3aa32bd66..e8b808514 100644
--- a/crates/ra_hir/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir/src/nameres/mod_resolution.rs
@@ -1,187 +1,87 @@
 //! This module resolves `mod foo;` declaration to file.
-
-use std::{borrow::Cow, sync::Arc};
-
-use ra_db::{FileId, SourceRoot};
+use ra_db::FileId;
 use ra_syntax::SmolStr;
 use relative_path::RelativePathBuf;
 
 use crate::{db::DefDatabase, HirFileId, Name};
 
-#[derive(Clone, Copy)]
-pub(super) struct ParentModule<'a> {
-    pub(super) name: &'a Name,
-    pub(super) attr_path: Option<&'a SmolStr>,
+#[derive(Clone, Debug)]
+pub(super) struct ModDir {
+    /// `.` for `mod.rs`, `lib.rs`
+    /// `./foo` for `foo.rs`
+    /// `./foo/bar` for `mod bar { mod x; }` nested in `foo.rs`
+    path: RelativePathBuf,
+    /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/`
+    root_non_dir_owner: bool,
 }
 
-impl<'a> ParentModule<'a> {
-    fn attribute_path(&self) -> Option<&SmolStr> {
-        self.attr_path.filter(|p| !p.is_empty())
+impl ModDir {
+    pub(super) fn root() -> ModDir {
+        ModDir { path: RelativePathBuf::default(), root_non_dir_owner: false }
     }
-}
 
-pub(super) fn resolve_submodule(
-    db: &impl DefDatabase,
-    file_id: HirFileId,
-    mod_attr_path: Option<&SmolStr>,
-    name: &Name,
-    is_root: bool,
-    attr_path: Option<&SmolStr>,
-    parent_module: Option<ParentModule<'_>>,
-) -> Result<FileId, RelativePathBuf> {
-    let file_id = file_id.original_file(db);
-    let source_root_id = db.file_source_root(file_id);
-    let path = db.file_relative_path(file_id);
-    let root = RelativePathBuf::default();
-    let dir_path = path.parent().unwrap_or(&root);
-    let mod_name = path.file_stem().unwrap_or("unknown");
-
-    let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
-        (Some(file_path), Some(parent_module)) => {
-            let file_path = normalize_attribute_path(file_path);
-            match parent_module.attribute_path() {
-                Some(parent_module_attr_path) => {
-                    let path = dir_path
-                        .join(format!(
-                            "{}/{}",
-                            normalize_attribute_path(parent_module_attr_path),
-                            file_path
-                        ))
-                        .normalize();
-                    ResolutionMode::InlineModuleWithAttributePath(
-                        InsideInlineModuleMode::WithAttributePath(path),
-                    )
-                }
-                None => {
-                    let path =
-                        dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
-                    ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
-                        path,
-                    ))
+    pub(super) fn descend_into_definition(
+        &self,
+        name: &Name,
+        attr_path: Option<&SmolStr>,
+    ) -> ModDir {
+        let mut path = self.path.clone();
+        match attr_to_path(attr_path) {
+            None => path.push(&name.to_string()),
+            Some(attr_path) => {
+                if self.root_non_dir_owner {
+                    // Workaround for relative path API: turn `lib.rs` into ``.
+                    if !path.pop() {
+                        path = RelativePathBuf::default();
+                    }
                 }
+                path.push(attr_path);
             }
         }
-        (None, Some(parent_module)) => match parent_module.attribute_path() {
-            Some(parent_module_attr_path) => {
-                let path = dir_path.join(format!(
-                    "{}/{}.rs",
-                    normalize_attribute_path(parent_module_attr_path),
-                    name
-                ));
-                ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
+        ModDir { path, root_non_dir_owner: false }
+    }
+
+    pub(super) fn resolve_declaration(
+        &self,
+        db: &impl DefDatabase,
+        file_id: HirFileId,
+        name: &Name,
+        attr_path: Option<&SmolStr>,
+    ) -> Result<(FileId, ModDir), RelativePathBuf> {
+        let empty_path = RelativePathBuf::default();
+        let file_id = file_id.original_file(db);
+
+        let mut candidate_files = Vec::new();
+        match attr_to_path(attr_path) {
+            Some(attr_path) => {
+                let base = if self.root_non_dir_owner {
+                    self.path.parent().unwrap_or(&empty_path)
+                } else {
+                    &self.path
+                };
+                candidate_files.push(base.join(attr_path))
             }
             None => {
-                let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
-                ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
-            }
-        },
-        (Some(file_path), None) => {
-            let file_path = normalize_attribute_path(file_path);
-            let path = dir_path.join(file_path.as_ref()).normalize();
-            ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
-        }
-        (None, None) => {
-            let is_dir_owner = is_root || mod_name == "mod" || mod_attr_path.is_some();
-            if is_dir_owner {
-                let file_mod = dir_path.join(format!("{}.rs", name));
-                let dir_mod = dir_path.join(format!("{}/mod.rs", name));
-                ResolutionMode::OutOfLine(OutOfLineMode::RootOrModRs {
-                    file: file_mod,
-                    directory: dir_mod,
-                })
-            } else {
-                let path = dir_path.join(format!("{}/{}.rs", mod_name, name));
-                ResolutionMode::OutOfLine(OutOfLineMode::FileInDirectory(path))
+                candidate_files.push(self.path.join(&format!("{}.rs", name)));
+                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
             }
-        }
-    };
-
-    resolve_mode.resolve(db.source_root(source_root_id))
-}
-
-fn normalize_attribute_path(file_path: &SmolStr) -> Cow<str> {
-    let current_dir = "./";
-    let windows_path_separator = r#"\"#;
-    let current_dir_normalize = if file_path.starts_with(current_dir) {
-        &file_path[current_dir.len()..]
-    } else {
-        file_path.as_str()
-    };
-    if current_dir_normalize.contains(windows_path_separator) {
-        Cow::Owned(current_dir_normalize.replace(windows_path_separator, "/"))
-    } else {
-        Cow::Borrowed(current_dir_normalize)
-    }
-}
-
-enum OutOfLineMode {
-    RootOrModRs { file: RelativePathBuf, directory: RelativePathBuf },
-    FileInDirectory(RelativePathBuf),
-    WithAttributePath(RelativePathBuf),
-}
-
-impl OutOfLineMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        match self {
-            OutOfLineMode::RootOrModRs { file, directory } => {
-                match source_root.file_by_relative_path(file) {
-                    None => resolve_simple_path(source_root, directory).map_err(|_| file.clone()),
-                    file_id => resolve_find_result(file_id, file),
+        };
+
+        for candidate in candidate_files.iter() {
+            if let Some(file_id) = db.resolve_relative_path(file_id, candidate) {
+                let mut root_non_dir_owner = false;
+                let mut mod_path = RelativePathBuf::new();
+                if !(candidate.ends_with("mod.rs") || attr_path.is_some()) {
+                    root_non_dir_owner = true;
+                    mod_path.push(&name.to_string());
                 }
+                return Ok((file_id, ModDir { path: mod_path, root_non_dir_owner }));
             }
-            OutOfLineMode::FileInDirectory(path) => resolve_simple_path(source_root, path),
-            OutOfLineMode::WithAttributePath(path) => resolve_simple_path(source_root, path),
         }
+        Err(candidate_files.remove(0))
     }
 }
 
-enum InsideInlineModuleMode {
-    File(RelativePathBuf),
-    WithAttributePath(RelativePathBuf),
-}
-
-impl InsideInlineModuleMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        match self {
-            InsideInlineModuleMode::File(path) => resolve_simple_path(source_root, path),
-            InsideInlineModuleMode::WithAttributePath(path) => {
-                resolve_simple_path(source_root, path)
-            }
-        }
-    }
-}
-
-enum ResolutionMode {
-    OutOfLine(OutOfLineMode),
-    InsideInlineModule(InsideInlineModuleMode),
-    InlineModuleWithAttributePath(InsideInlineModuleMode),
-}
-
-impl ResolutionMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        use self::ResolutionMode::*;
-
-        match self {
-            OutOfLine(mode) => mode.resolve(source_root),
-            InsideInlineModule(mode) => mode.resolve(source_root),
-            InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
-        }
-    }
-}
-
-fn resolve_simple_path(
-    source_root: Arc<SourceRoot>,
-    path: &RelativePathBuf,
-) -> Result<FileId, RelativePathBuf> {
-    resolve_find_result(source_root.file_by_relative_path(path), path)
-}
-
-fn resolve_find_result(
-    file_id: Option<FileId>,
-    path: &RelativePathBuf,
-) -> Result<FileId, RelativePathBuf> {
-    match file_id {
-        Some(file_id) => Ok(file_id.clone()),
-        None => Err(path.clone()),
-    }
+fn attr_to_path(attr: Option<&SmolStr>) -> Option<RelativePathBuf> {
+    attr.and_then(|it| RelativePathBuf::from_path(&it.replace("\\", "/")).ok())
 }
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 623b343c4..57f2929c3 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -5,7 +5,7 @@ use std::{ops::Index, sync::Arc};
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SmolStr, SourceFile,
+    AstNode, AstPtr, SourceFile,
 };
 use test_utils::tested_by;
 
@@ -121,14 +121,20 @@ impl Index<Macro> for RawItems {
 }
 
 // Avoid heap allocation on items without attributes.
-pub(super) type Attrs = Option<Arc<[Attr]>>;
+type Attrs = Option<Arc<[Attr]>>;
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub(super) struct RawItem {
-    pub(super) attrs: Attrs,
+    attrs: Attrs,
     pub(super) kind: RawItemKind,
 }
 
+impl RawItem {
+    pub(super) fn attrs(&self) -> &[Attr] {
+        self.attrs.as_ref().map_or(&[], |it| &*it)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub(super) enum RawItemKind {
     Module(Module),
@@ -143,19 +149,8 @@ impl_arena_id!(Module);
 
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum ModuleData {
-    Declaration {
-        name: Name,
-        ast_id: FileAstId<ast::Module>,
-        attr_path: Option<SmolStr>,
-        is_macro_use: bool,
-    },
-    Definition {
-        name: Name,
-        ast_id: FileAstId<ast::Module>,
-        items: Vec<RawItem>,
-        attr_path: Option<SmolStr>,
-        is_macro_use: bool,
-    },
+    Declaration { name: Name, ast_id: FileAstId<ast::Module> },
+    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -286,28 +281,17 @@ impl<DB: AstDatabase> RawItemsCollector<&DB> {
         let attrs = self.parse_attrs(&module);
 
         let ast_id = self.source_ast_id_map.ast_id(&module);
-        // FIXME: cfg_attr
-        let is_macro_use = module.has_atom_attr("macro_use");
         if module.has_semi() {
-            let attr_path = extract_mod_path_attribute(&module);
-            let item = self.raw_items.modules.alloc(ModuleData::Declaration {
-                name,
-                ast_id,
-                attr_path,
-                is_macro_use,
-            });
+            let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id });
             self.push_item(current_module, attrs, RawItemKind::Module(item));
             return;
         }
 
         if let Some(item_list) = module.item_list() {
-            let attr_path = extract_mod_path_attribute(&module);
             let item = self.raw_items.modules.alloc(ModuleData::Definition {
                 name,
                 ast_id,
                 items: Vec::new(),
-                attr_path,
-                is_macro_use,
             });
             self.process_module(Some(item), item_list);
             self.push_item(current_module, attrs, RawItemKind::Module(item));
@@ -417,16 +401,3 @@ impl<DB: AstDatabase> RawItemsCollector<&DB> {
         Attr::from_attrs_owner(self.file_id, item, self.db)
     }
 }
-
-fn extract_mod_path_attribute(module: &ast::Module) -> Option<SmolStr> {
-    module.attrs().into_iter().find_map(|attr| {
-        attr.as_simple_key_value().and_then(|(name, value)| {
-            let is_path = name == "path";
-            if is_path {
-                Some(value)
-            } else {
-                None
-            }
-        })
-    })
-}
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 34dd79574..8c6b40aaf 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -7,7 +7,6 @@ mod mod_resolution;
 use std::sync::Arc;
 
 use insta::assert_snapshot;
-use ra_cfg::CfgOptions;
 use ra_db::SourceDatabase;
 use test_utils::covers;
 
@@ -561,12 +560,12 @@ fn cfg_test() {
         "#,
         crate_graph! {
             "main": ("/main.rs", ["std"]),
-            "std": ("/lib.rs", [], CfgOptions::default()
-                .atom("test".into())
-                .key_value("feature".into(), "foo".into())
-                .key_value("feature".into(), "bar".into())
-                .key_value("opt".into(), "42".into())
-            ),
+            "std": ("/lib.rs", [], cfg = {
+                "test",
+                "feature" = "foo",
+                "feature" = "bar",
+                "opt" = "42",
+            }),
         },
     );
 
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index c41862a0b..af9c39760 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -2,7 +2,7 @@ use super::*;
 
 use std::sync::Arc;
 
-use ra_db::SourceDatabase;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
 
 fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
     let (mut db, pos) = MockDatabase::with_position(initial);
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
index e4b408394..4f52ad2c5 100644
--- a/crates/ra_hir/src/nameres/tests/macros.rs
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -38,21 +38,34 @@ fn macro_rules_can_define_modules() {
         }
         m!(n1);
 
+        mod m {
+            m!(n3)
+        }
+
         //- /n1.rs
         m!(n2)
         //- /n1/n2.rs
         struct X;
+        //- /m/n3.rs
+        struct Y;
         ",
     );
     assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮n1: t
-   ⋮
-   ⋮crate::n1
-   ⋮n2: t
-   ⋮
-   ⋮crate::n1::n2
-   ⋮X: t v
+    crate
+    m: t
+    n1: t
+    
+    crate::m
+    n3: t
+    
+    crate::m::n3
+    Y: t v
+    
+    crate::n1
+    n2: t
+    
+    crate::n1::n2
+    X: t v
     "###);
 }
 
diff --git a/crates/ra_hir/src/nameres/tests/mod_resolution.rs b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
index e3e6f1e95..f569aacdc 100644
--- a/crates/ra_hir/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
@@ -26,6 +26,33 @@ fn name_res_works_for_broken_modules() {
 }
 
 #[test]
+fn nested_module_resolution() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod n1;
+
+        //- /n1.rs
+        mod n2;
+
+        //- /n1/n2.rs
+        struct X;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮n1: t
+        ⋮
+        ⋮crate::n1
+        ⋮n2: t
+        ⋮
+        ⋮crate::n1::n2
+        ⋮X: t v
+    "###);
+}
+
+#[test]
 fn module_resolution_works_for_non_standard_filenames() {
     let map = def_map_with_crate_graph(
         "
@@ -53,18 +80,15 @@ fn module_resolution_works_for_non_standard_filenames() {
 
 #[test]
 fn module_resolution_works_for_raw_modules() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         "
-        //- /library.rs
+        //- /lib.rs
         mod r#async;
         use self::r#async::Bar;
 
         //- /async.rs
         pub struct Bar;
         ",
-        crate_graph! {
-            "library": ("/library.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -79,9 +103,9 @@ fn module_resolution_works_for_raw_modules() {
 
 #[test]
 fn module_resolution_decl_path() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
-        //- /library.rs
+        //- /lib.rs
         #[path = "bar/baz/foo.rs"]
         mod foo;
         use self::foo::Bar;
@@ -89,9 +113,6 @@ fn module_resolution_decl_path() {
         //- /bar/baz/foo.rs
         pub struct Bar;
         "###,
-        crate_graph! {
-            "library": ("/library.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -106,7 +127,7 @@ fn module_resolution_decl_path() {
 
 #[test]
 fn module_resolution_module_with_path_in_mod_rs() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -120,9 +141,6 @@ fn module_resolution_module_with_path_in_mod_rs() {
         //- /foo/baz.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -140,7 +158,7 @@ fn module_resolution_module_with_path_in_mod_rs() {
 
 #[test]
 fn module_resolution_module_with_path_non_crate_root() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -154,9 +172,6 @@ fn module_resolution_module_with_path_non_crate_root() {
         //- /baz.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -174,7 +189,7 @@ fn module_resolution_module_with_path_non_crate_root() {
 
 #[test]
 fn module_resolution_module_decl_path_super() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "bar/baz/module.rs"]
@@ -184,9 +199,6 @@ fn module_resolution_module_decl_path_super() {
         //- /bar/baz/module.rs
         use super::Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -201,7 +213,7 @@ fn module_resolution_module_decl_path_super() {
 
 #[test]
 fn module_resolution_explicit_path_mod_rs() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "module/mod.rs"]
@@ -210,9 +222,6 @@ fn module_resolution_explicit_path_mod_rs() {
         //- /module/mod.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -226,7 +235,7 @@ fn module_resolution_explicit_path_mod_rs() {
 
 #[test]
 fn module_resolution_relative_path() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -238,9 +247,6 @@ fn module_resolution_relative_path() {
         //- /sub.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -257,7 +263,7 @@ fn module_resolution_relative_path() {
 
 #[test]
 fn module_resolution_relative_path_2() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -269,9 +275,6 @@ fn module_resolution_relative_path_2() {
         //- /sub.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -288,7 +291,7 @@ fn module_resolution_relative_path_2() {
 
 #[test]
 fn module_resolution_explicit_path_mod_rs_2() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "module/bar/mod.rs"]
@@ -297,9 +300,6 @@ fn module_resolution_explicit_path_mod_rs_2() {
         //- /module/bar/mod.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -313,7 +313,7 @@ fn module_resolution_explicit_path_mod_rs_2() {
 
 #[test]
 fn module_resolution_explicit_path_mod_rs_with_win_separator() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "module\bar\mod.rs"]
@@ -322,9 +322,6 @@ fn module_resolution_explicit_path_mod_rs_with_win_separator() {
         //- /module/bar/mod.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -338,7 +335,7 @@ fn module_resolution_explicit_path_mod_rs_with_win_separator() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_with_path_attribute() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "models"]
@@ -349,9 +346,6 @@ fn module_resolution_decl_inside_inline_module_with_path_attribute() {
         //- /models/bar.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -368,7 +362,7 @@ fn module_resolution_decl_inside_inline_module_with_path_attribute() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo {
@@ -378,9 +372,6 @@ fn module_resolution_decl_inside_inline_module() {
         //- /foo/bar.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -397,7 +388,7 @@ fn module_resolution_decl_inside_inline_module() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "models/db"]
@@ -408,9 +399,6 @@ fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
         //- /models/db/bar.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -427,7 +415,7 @@ fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_3() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "models/db"]
@@ -439,9 +427,6 @@ fn module_resolution_decl_inside_inline_module_3() {
         //- /models/db/users.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -458,7 +443,7 @@ fn module_resolution_decl_inside_inline_module_3() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_empty_path() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = ""]
@@ -467,12 +452,9 @@ fn module_resolution_decl_inside_inline_module_empty_path() {
             mod bar;
         }
 
-        //- /foo/users.rs
+        //- /users.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -489,32 +471,25 @@ fn module_resolution_decl_inside_inline_module_empty_path() {
 
 #[test]
 fn module_resolution_decl_empty_path() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
-        #[path = ""]
+        #[path = ""] // Should try to read `/` (a directory)
         mod foo;
 
         //- /foo.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
         ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
     "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_relative_path() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path = "./models"]
@@ -525,9 +500,6 @@ fn module_resolution_decl_inside_inline_module_relative_path() {
         //- /models/bar.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -544,7 +516,7 @@ fn module_resolution_decl_inside_inline_module_relative_path() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_crate_root() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo {
@@ -556,9 +528,6 @@ fn module_resolution_decl_inside_inline_module_in_crate_root() {
         //- /foo/baz.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -576,7 +545,7 @@ fn module_resolution_decl_inside_inline_module_in_crate_root() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_mod_rs() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -591,9 +560,6 @@ fn module_resolution_decl_inside_inline_module_in_mod_rs() {
         //- /foo/bar/qwe.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -614,7 +580,7 @@ fn module_resolution_decl_inside_inline_module_in_mod_rs() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -626,12 +592,9 @@ fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
         }
         use self::bar::baz::Baz;
 
-        //- /bar/qwe.rs
+        //- /foo/bar/qwe.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -652,7 +615,7 @@ fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         mod foo;
@@ -667,9 +630,6 @@ fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
         //- /bar/baz.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -709,7 +669,7 @@ fn unresolved_module_diagnostics() {
 
 #[test]
 fn module_resolution_decl_inside_module_in_non_crate_root_2() {
-    let map = def_map_with_crate_graph(
+    let map = def_map(
         r###"
         //- /main.rs
         #[path="module/m2.rs"]
@@ -721,9 +681,6 @@ fn module_resolution_decl_inside_module_in_non_crate_root_2() {
         //- /module/submod.rs
         pub struct Baz;
         "###,
-        crate_graph! {
-            "main": ("/main.rs", []),
-        },
     );
 
     assert_snapshot!(map, @r###"
@@ -737,3 +694,66 @@ fn module_resolution_decl_inside_module_in_non_crate_root_2() {
         ⋮Baz: t v
     "###);
 }
+
+#[test]
+fn nested_out_of_line_module() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod a {
+            mod b {
+                mod c;
+            }
+        }
+
+        //- /a/b/c.rs
+        struct X;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+    crate
+    a: t
+    
+    crate::a
+    b: t
+    
+    crate::a::b
+    c: t
+    
+    crate::a::b::c
+    X: t v
+    "###);
+}
+
+#[test]
+fn nested_out_of_line_module_with_path() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod a {
+            #[path = "d/e"]
+            mod b {
+                mod c;
+            }
+        }
+
+        //- /a/d/e/c.rs
+        struct X;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+    crate
+    a: t
+    
+    crate::a
+    b: t
+    
+    crate::a::b
+    c: t
+    
+    crate::a::b::c
+    X: t v
+    "###);
+}