1 files changed, 63 insertions, 186 deletions

diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 7da2dcdff..5af26f953 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -1,9 +1,5 @@
-use std::borrow::Cow;
-use std::sync::Arc;
-
-use ra_db::{FileId, SourceRoot};
-use ra_syntax::{ast, SmolStr};
-use relative_path::RelativePathBuf;
+use ra_db::FileId;
+use ra_syntax::ast;
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
@@ -12,8 +8,10 @@ use crate::{
     ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind},
     name::MACRO_RULES,
     nameres::{
-        diagnostics::DefDiagnostic, raw, CrateDefMap, CrateModuleId, ItemOrMacro, ModuleData,
-        ModuleDef, PerNs, ReachedFixedPoint, Resolution, ResolveMode,
+        diagnostics::DefDiagnostic,
+        mod_resolution::{resolve_submodule, ParentModule},
+        raw, CrateDefMap, CrateModuleId, ItemOrMacro, ModuleData, ModuleDef, PerNs,
+        ReachedFixedPoint, Resolution, ResolveMode,
     },
     AstId, Const, DefDatabase, Enum, Function, HirFileId, MacroDef, Module, Name, Path, Static,
     Struct, Trait, TypeAlias, Union,
@@ -157,11 +155,45 @@ where
         // crate root, even if the parent modules is **not** visible.
         if export {
             self.update(self.def_map.root, None, &[(name.clone(), def.clone())]);
+
+            // Exported macros are collected in crate level ready for
+            // glob import with `#[macro_use]`.
+            self.def_map.exported_macros.insert(name.clone(), macro_id);
         }
         self.update(module_id, None, &[(name.clone(), def)]);
         self.global_macro_scope.insert(name, macro_id);
     }
 
+    /// Import macros from `#[macro_use] extern crate`.
+    ///
+    /// They are non-scoped, and will only be inserted into mutable `global_macro_scope`.
+    fn import_macros_from_extern_crate(&mut self, import: &raw::ImportData) {
+        log::debug!(
+            "importing macros from extern crate: {:?} ({:?})",
+            import,
+            self.def_map.edition,
+        );
+
+        let res = self.def_map.resolve_name_in_extern_prelude(
+            &import
+                .path
+                .as_ident()
+                .expect("extern crate should have been desugared to one-element path"),
+        );
+
+        if let Some(ModuleDef::Module(m)) = res.take_types() {
+            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
+            self.import_all_macros_exported(m);
+        }
+    }
+
+    fn import_all_macros_exported(&mut self, module: Module) {
+        let item_map = self.db.crate_def_map(module.krate);
+        for (name, &macro_id) in &item_map.exported_macros {
+            self.global_macro_scope.insert(name.clone(), macro_id);
+        }
+    }
+
     fn resolve_imports(&mut self) -> ReachedFixedPoint {
         let mut imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
         let mut resolved = Vec::new();
@@ -491,13 +523,31 @@ where
     DB: DefDatabase,
 {
     fn collect(&mut self, items: &[raw::RawItem]) {
+        // Prelude module is always considered to be `#[macro_use]`.
+        if let Some(prelude_module) = self.def_collector.def_map.prelude {
+            tested_by!(prelude_is_macro_use);
+            self.def_collector.import_all_macros_exported(prelude_module);
+        }
+
+        // This should be processed eagerly instead of deferred to resolving.
+        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
+        // any other items.
+        for item in items {
+            if let raw::RawItem::Import(import_id) = *item {
+                let import = self.raw_items[import_id].clone();
+                if import.is_extern_crate && import.is_macro_use {
+                    self.def_collector.import_macros_from_extern_crate(&import);
+                }
+            }
+        }
+
         for item in items {
             match *item {
                 raw::RawItem::Module(m) => self.collect_module(&self.raw_items[m]),
-                raw::RawItem::Import(import) => self.def_collector.unresolved_imports.push((
+                raw::RawItem::Import(import_id) => self.def_collector.unresolved_imports.push((
                     self.module_id,
-                    import,
-                    self.raw_items[import].clone(),
+                    import_id,
+                    self.raw_items[import_id].clone(),
                 )),
                 raw::RawItem::Def(def) => self.define_def(&self.raw_items[def]),
                 raw::RawItem::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
@@ -531,7 +581,7 @@ where
                     name,
                     is_root,
                     attr_path.as_ref(),
-                    self.parent_module.as_ref(),
+                    self.parent_module,
                 ) {
                     Ok(file_id) => {
                         let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
@@ -642,180 +692,6 @@ fn is_macro_rules(path: &Path) -> bool {
     path.as_ident() == Some(&MACRO_RULES)
 }
 
-fn resolve_submodule(
-    db: &impl DefDatabase,
-    file_id: HirFileId,
-    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,
-                    ))
-                }
-            }
-        }
-        (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))
-            }
-            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))
-        }
-        _ => {
-            let is_dir_owner = is_root || mod_name == "mod";
-            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))
-            }
-        }
-    };
-
-    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.files.get(file) {
-                None => resolve_simple_path(source_root, directory).map_err(|_| file.clone()),
-                file_id => resolve_find_result(file_id, file),
-            },
-            OutOfLineMode::FileInDirectory(path) => resolve_simple_path(source_root, path),
-            OutOfLineMode::WithAttributePath(path) => resolve_simple_path(source_root, path),
-        }
-    }
-}
-
-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.files.get(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()),
-    }
-}
-
-struct ParentModule<'a> {
-    name: &'a Name,
-    attr_path: Option<&'a SmolStr>,
-}
-
-impl<'a> ParentModule<'a> {
-    pub fn attribute_path(&self) -> Option<&SmolStr> {
-        self.attr_path.filter(|p| !p.is_empty())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use ra_db::SourceDatabase;
@@ -860,6 +736,7 @@ mod tests {
                 root,
                 modules,
                 poison_macros: FxHashSet::default(),
+                exported_macros: FxHashMap::default(),
                 diagnostics: Vec::new(),
             }
         };