Consider prelude to be macro_use

crates/ra_hir/src/marks.rs

@@ -12,4 +12,5 @@ test_utils::marks!(
     trait_resolution_on_fn_type
     infer_while_let
     macro_rules_from_other_crates_are_visible_with_macro_use
+    prelude_is_macro_use
 );

crates/ra_hir/src/nameres/collector.rs

@@ -185,13 +185,16 @@ where
 
         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);
+        }
+    }
 
-            let item_map = self.db.crate_def_map(m.krate);
+    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());
@@ -522,6 +525,12 @@ 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);
+        }
+
         for item in items {
             match *item {
                 raw::RawItem::Module(m) => self.collect_module(&self.raw_items[m]),

crates/ra_hir/src/nameres/tests/macros.rs

@@ -191,3 +191,60 @@ fn macro_rules_from_other_crates_are_visible_with_macro_use() {
    ⋮Baz: t v
     "###);
 }
+
+#[test]
+fn prelude_is_macro_use() {
+    covers!(prelude_is_macro_use);
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        structs!(Foo);
+        structs_priv!(Bar);
+        structs_outside!(Out);
+        crate::structs!(MacroNotResolved2);
+
+        mod bar;
+
+        //- /bar.rs
+        structs!(Baz);
+        crate::structs!(MacroNotResolved3);
+
+        //- /lib.rs
+        #[prelude_import]
+        use self::prelude::*;
+
+        mod prelude {
+            #[macro_export]
+            macro_rules! structs {
+                ($i:ident) => { struct $i; }
+            }
+
+            mod priv_mod {
+                #[macro_export]
+                macro_rules! structs_priv {
+                    ($i:ident) => { struct $i; }
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! structs_outside {
+            ($i:ident) => { struct $i; }
+        }
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮Out: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Baz: t v
+    "###);
+}