Auto merge of #52234 - petrochenkov:macuse2, r=<try>

[Experiment] resolve: Modularize crate-local `#[macro_export] macro_rules`

Based on #50911, cc #50911 (comment)

`#[macro_export] macro_rules` items are collected from the whole crate and are planted into the root module as items, so the external view of the crate is symmetric with its internal view and something like `$crate::my_macro` where `my_macro` is `#[macro_export] macro_rules` works both locally and from other crates.

Author: bors

Diff for: src/doc/unstable-book/src/language-features/proc-macro.md

@@ -17,8 +17,7 @@ The two new procedural macro kinds are:
 * Attribute-like procedural macros which can be applied to any item which built-in attributes can
 be applied to, and which can take arguments in their invocation as well.
 
-Additionally, this feature flag implicitly enables the [`use_extern_macros`](language-features/use-extern-macros.html) feature,
-which allows macros to be imported like any other item with `use` statements, as compared to 
+Procedural macros can be imported like any other item with `use` statements, as compared to
 applying `#[macro_use]` to an `extern crate` declaration. It is important to note that procedural macros may
 **only** be imported in this manner, and will throw an error otherwise.
 

Diff for: src/librustc_resolve/build_reduced_graph.rs

@@ -52,6 +52,7 @@ impl<'a> ToNameBinding<'a> for (Module<'a>, ty::Visibility, Span, Mark) {
             vis: self.1,
             span: self.2,
             expansion: self.3,
+            is_macro_export: false,
         })
     }
 }
@@ -63,6 +64,19 @@ impl<'a> ToNameBinding<'a> for (Def, ty::Visibility, Span, Mark) {
             vis: self.1,
             span: self.2,
             expansion: self.3,
+            is_macro_export: false,
+        })
+    }
+}
+
+impl<'a> ToNameBinding<'a> for (Def, ty::Visibility, Span, Mark, bool) {
+    fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
+        arenas.alloc_name_binding(NameBinding {
+            kind: NameBindingKind::Def(self.0),
+            vis: self.1,
+            span: self.2,
+            expansion: self.3,
+            is_macro_export: self.4,
         })
     }
 }
@@ -641,19 +655,12 @@ impl<'a> Resolver<'a> {
                                     -> bool {
         let allow_shadowing = expansion == Mark::root();
         let legacy_imports = self.legacy_macro_imports(&item.attrs);
-        let mut used = legacy_imports != LegacyMacroImports::default();
+        let used = legacy_imports != LegacyMacroImports::default();
 
         // `#[macro_use]` is only allowed at the crate root.
         if self.current_module.parent.is_some() && used {
             span_err!(self.session, item.span, E0468,
                       "an `extern crate` loading macros must be at the crate root");
-        } else if !self.use_extern_macros && !used &&
-                  self.cstore.dep_kind_untracked(module.def_id().unwrap().krate)
-                      .macros_only() {
-            let msg = "proc macro crates and `#[no_link]` crates have no effect without \
-                       `#[macro_use]`";
-            self.session.span_warn(item.span, msg);
-            used = true; // Avoid the normal unused extern crate warning
         }
 
         let (graph_root, arenas) = (self.graph_root, self.arenas);
@@ -681,8 +688,7 @@ impl<'a> Resolver<'a> {
         } else {
             for (name, span) in legacy_imports.imports {
                 let ident = Ident::with_empty_ctxt(name);
-                let result = self.resolve_ident_in_module(module, ident, MacroNS,
-                                                          false, false, span);
+                let result = self.resolve_ident_in_module(module, ident, MacroNS, false, span);
                 if let Ok(binding) = result {
                     let directive = macro_use_directive(span);
                     self.potentially_unused_imports.push(directive);
@@ -750,6 +756,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
     fn visit_invoc(&mut self, id: ast::NodeId) -> &'b InvocationData<'b> {
         let mark = id.placeholder_to_mark();
         self.resolver.current_module.unresolved_invocations.borrow_mut().insert(mark);
+        self.resolver.unresolved_invocations_macro_export.insert(mark);
         let invocation = self.resolver.invocations[&mark];
         invocation.module.set(self.resolver.current_module);
         invocation.legacy_scope.set(self.legacy_scope);