Stabilize use_extern_macros

Author: petrochenkov

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.
 

src/librustc_resolve/build_reduced_graph.rs

@@ -641,19 +641,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);

src/librustc_resolve/lib.rs

@@ -1380,13 +1380,10 @@ pub struct Resolver<'a> {
     /// `use` injections for proc macros wrongly imported with #[macro_use]
     proc_mac_errors: Vec<macros::ProcMacError>,
 
-    gated_errors: FxHashSet<Span>,
     disallowed_shadowing: Vec<&'a LegacyBinding<'a>>,
 
     arenas: &'a ResolverArenas<'a>,
     dummy_binding: &'a NameBinding<'a>,
-    /// true if `#![feature(use_extern_macros)]`
-    use_extern_macros: bool,
 
     crate_loader: &'a mut CrateLoader,
     macro_names: FxHashSet<Ident>,
@@ -1698,7 +1695,6 @@ impl<'a> Resolver<'a> {
             ambiguity_errors: Vec::new(),
             use_injections: Vec::new(),
             proc_mac_errors: Vec::new(),
-            gated_errors: FxHashSet(),
             disallowed_shadowing: Vec::new(),
 
             arenas,
@@ -1709,10 +1705,6 @@ impl<'a> Resolver<'a> {
                 vis: ty::Visibility::Public,
             }),
 
-            // The `proc_macro` and `decl_macro` features imply `use_extern_macros`
-            use_extern_macros:
-                features.use_extern_macros || features.proc_macro || features.decl_macro,
-
             crate_loader,
             macro_names: FxHashSet(),
             global_macros: FxHashMap(),
@@ -1753,9 +1745,7 @@ impl<'a> Resolver<'a> {
     fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, mut f: F) {
         f(self, TypeNS);
         f(self, ValueNS);
-        if self.use_extern_macros {
-            f(self, MacroNS);
-        }
+        f(self, MacroNS);
     }
 
     fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId {

src/librustc_resolve/macros.rs

@@ -458,21 +458,13 @@ impl<'a> Resolver<'a> {
         self.current_module = if module.is_trait() { module.parent.unwrap() } else { module };
 
         // Possibly apply the macro helper hack
-        if self.use_extern_macros && kind == MacroKind::Bang && path.len() == 1 &&
+        if kind == MacroKind::Bang && path.len() == 1 &&
            path[0].span.ctxt().outer().expn_info().map_or(false, |info| info.local_inner_macros) {
             let root = Ident::new(keywords::DollarCrate.name(), path[0].span);
             path.insert(0, root);
         }
 
         if path.len() > 1 {
-            if !self.use_extern_macros && self.gated_errors.insert(span) {
-                let msg = "non-ident macro paths are experimental";
-                let feature = "use_extern_macros";
-                emit_feature_err(&self.session.parse_sess, feature, span, GateIssue::Language, msg);
-                self.found_unresolved_macro = true;
-                return Err(Determinacy::Determined);
-            }
-
             let def = match self.resolve_path(&path, Some(MacroNS), false, span, CrateLint::No) {
                 PathResult::NonModule(path_res) => match path_res.base_def() {
                     Def::Err => Err(Determinacy::Determined),
@@ -588,7 +580,6 @@ impl<'a> Resolver<'a> {
                                 record_used: bool)
                                 -> Option<MacroBinding<'a>> {
         let ident = ident.modern();
-        let mut possible_time_travel = None;
         let mut relative_depth: u32 = 0;
         let mut binding = None;
         loop {
@@ -598,9 +589,6 @@ impl<'a> Resolver<'a> {
                     match invocation.expansion.get() {
                         LegacyScope::Invocation(_) => scope.set(invocation.legacy_scope.get()),
                         LegacyScope::Empty => {
-                            if possible_time_travel.is_none() {
-                                possible_time_travel = Some(scope);
-                            }
                             scope = &invocation.legacy_scope;
                         }
                         _ => {
@@ -615,7 +603,7 @@ impl<'a> Resolver<'a> {
                 }
                 LegacyScope::Binding(potential_binding) => {
                     if potential_binding.ident == ident {
-                        if (!self.use_extern_macros || record_used) && relative_depth > 0 {
+                        if record_used && relative_depth > 0 {
                             self.disallowed_shadowing.push(potential_binding);
                         }
                         binding = Some(potential_binding);
@@ -629,21 +617,11 @@ impl<'a> Resolver<'a> {
         let binding = if let Some(binding) = binding {
             MacroBinding::Legacy(binding)
         } else if let Some(binding) = self.global_macros.get(&ident.name).cloned() {
-            if !self.use_extern_macros {
-                self.record_use(ident, MacroNS, binding, DUMMY_SP);
-            }
             MacroBinding::Global(binding)
         } else {
             return None;
         };
 
-        if !self.use_extern_macros {
-            if let Some(scope) = possible_time_travel {
-                // Check for disallowed shadowing later
-                self.lexical_macro_resolutions.push((ident, scope));
-            }
-        }
-
         Some(binding)
     }
 
@@ -749,9 +727,6 @@ impl<'a> Resolver<'a> {
             find_best_match_for_name(names, name, None)
         // Then check modules.
         }).or_else(|| {
-            if !self.use_extern_macros {
-                return None;
-            }
             let is_macro = |def| {
                 if let Def::Macro(_, def_kind) = def {
                     def_kind == kind

src/librustc_resolve/resolve_imports.rs

@@ -131,14 +131,11 @@ impl<'a> Default for SingleImports<'a> {
 }
 
 impl<'a> SingleImports<'a> {
-    fn add_directive(&mut self, directive: &'a ImportDirective<'a>, use_extern_macros: bool) {
+    fn add_directive(&mut self, directive: &'a ImportDirective<'a>) {
         match *self {
             SingleImports::None => *self = SingleImports::MaybeOne(directive),
-            SingleImports::MaybeOne(directive_one) => *self = if use_extern_macros {
-                SingleImports::MaybeTwo(directive_one, directive)
-            } else {
-                SingleImports::AtLeastOne
-            },
+            SingleImports::MaybeOne(directive_one) =>
+                *self = SingleImports::MaybeTwo(directive_one, directive),
             // If three single imports can define the name in the namespace, we can assume that at
             // least one of them will define it since otherwise we'd get duplicate errors in one of
             // other namespaces.
@@ -348,7 +345,7 @@ impl<'a> Resolver<'a> {
             SingleImport { target, type_ns_only, .. } => {
                 self.per_ns(|this, ns| if !type_ns_only || ns == TypeNS {
                     let mut resolution = this.resolution(current_module, target, ns).borrow_mut();
-                    resolution.single_imports.add_directive(directive, this.use_extern_macros);
+                    resolution.single_imports.add_directive(directive);
                 });
             }
             // We don't add prelude imports to the globs since they only affect lexical scopes,

src/libstd/lib.rs

@@ -312,7 +312,7 @@
 #![feature(unboxed_closures)]
 #![feature(untagged_unions)]
 #![feature(unwind_attributes)]
-#![feature(use_extern_macros)]
+#![cfg_attr(stage0, feature(use_extern_macros))]
 #![feature(vec_push_all)]
 #![feature(doc_cfg)]
 #![feature(doc_masked)]

src/libsyntax/feature_gate.rs

@@ -291,8 +291,6 @@ declare_features! (
     // Allows #[link(..., cfg(..))]
     (active, link_cfg, "1.14.0", Some(37406), None),
 
-    (active, use_extern_macros, "1.15.0", Some(35896), None),
-
     // `extern "ptx-*" fn()`
     (active, abi_ptx, "1.15.0", Some(38788), None),
 
@@ -509,7 +507,7 @@ declare_features! (
     (removed, advanced_slice_patterns, "1.0.0", Some(23121), None,
      Some("merged into `#![feature(slice_patterns)]`")),
     (removed, macro_reexport, "1.0.0", Some(29638), None,
-     Some("subsumed by `#![feature(use_extern_macros)]` and `pub use`")),
+     Some("subsumed by `pub use`")),
 );
 
 declare_features! (
@@ -624,6 +622,8 @@ declare_features! (
     (accepted, global_allocator, "1.28.0", Some(27389), None),
     // Allows `#[repr(transparent)]` attribute on newtype structs
     (accepted, repr_transparent, "1.28.0", Some(43036), None),
+    // Allows importing and reexporting macros with `use`.
+    (accepted, use_extern_macros, "1.29.0", Some(35896), None),
 );
 
 // If you change this, please modify src/doc/unstable-book as well. You must

src/test/compile-fail-fulldeps/proc-macro/feature-gate-proc_macro.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:attr_proc_macro.rs
-#![feature(use_extern_macros)]
 
 extern crate attr_proc_macro;
 use attr_proc_macro::attr_proc_macro;

src/test/compile-fail-fulldeps/proc-macro/lints_in_proc_macros.rs

@@ -11,8 +11,7 @@
 // aux-build:bang_proc_macro2.rs
 // ignore-stage1
 
-#![feature(use_extern_macros, proc_macro_non_items)]
-#![allow(unused_macros)]
+#![feature(proc_macro_non_items)]
 
 extern crate bang_proc_macro2;
 

src/test/compile-fail-fulldeps/proc-macro/no-macro-use-attr.rs

@@ -11,9 +11,10 @@
 // aux-build:derive-a.rs
 
 #![feature(rustc_attrs)]
+#![warn(unused_extern_crates)]
 
 extern crate derive_a;
-//~^ WARN proc macro crates and `#[no_link]` crates have no effect without `#[macro_use]`
+//~^ WARN unused extern crate
 
 #[rustc_error]
 fn main() {} //~ ERROR compilation successful