1 files changed, 41 insertions, 36 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(),
         };