-> 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);
directive.vis.get() == ty::Visibility::Public ||
directive.span.is_dummy() => {
if let ImportDirectiveSubclass::MacroUse = directive.subclass {
- if resolver.use_extern_macros && !directive.span.is_dummy() {
+ if !directive.span.is_dummy() {
resolver.session.buffer_lint(
lint::builtin::MACRO_USE_EXTERN_CRATE,
directive.id,
use rustc_data_structures::sync::Lrc;
use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver};
-use macros::{InvocationData, LegacyBinding, LegacyScope, MacroBinding};
+use macros::{InvocationData, LegacyBinding, MacroBinding};
// NB: This module needs to be declared first so diagnostics are
// registered before they are used.
/// crate-local macro expanded `macro_export` referred to by a module-relative path
macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>,
- 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<'b>,
macro_names: FxHashSet<Ident>,
macro_prelude: FxHashMap<Name, &'a NameBinding<'a>>,
pub all_macros: FxHashMap<Name, Def>,
- lexical_macro_resolutions: Vec<(Ident, &'a Cell<LegacyScope<'a>>)>,
macro_map: FxHashMap<DefId, Lrc<SyntaxExtension>>,
macro_defs: FxHashMap<Mark, DefId>,
local_macro_def_scopes: FxHashMap<NodeId, Module<'a>>,
- macro_exports: Vec<Export>, // FIXME: Remove when `use_extern_macros` is stabilized
pub whitelisted_legacy_custom_derives: Vec<Name>,
pub found_unresolved_macro: bool,
invocations.insert(Mark::root(),
arenas.alloc_invocation_data(InvocationData::root(graph_root)));
- let features = session.features_untracked();
-
let mut macro_defs = FxHashMap();
macro_defs.insert(Mark::root(), root_def_id);
ambiguity_errors: Vec::new(),
use_injections: Vec::new(),
proc_mac_errors: Vec::new(),
- gated_errors: FxHashSet(),
disallowed_shadowing: Vec::new(),
macro_expanded_macro_export_errors: BTreeSet::new(),
vis: ty::Visibility::Public,
}),
- use_extern_macros: features.use_extern_macros(),
-
crate_loader,
macro_names: FxHashSet(),
macro_prelude: FxHashMap(),
all_macros: FxHashMap(),
- lexical_macro_resolutions: Vec::new(),
macro_map: FxHashMap(),
- macro_exports: Vec::new(),
invocations,
macro_defs,
local_macro_def_scopes: FxHashMap(),
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 {
fn resolve_item(&mut self, item: &Item) {
let name = item.ident.name;
-
debug!("(resolving item) resolving {}", name);
- self.check_proc_macro_attrs(&item.attrs);
-
match item.node {
ItemKind::Enum(_, ref generics) |
ItemKind::Ty(_, ref generics) |
walk_list!(this, visit_param_bound, bounds);
for trait_item in trait_items {
- this.check_proc_macro_attrs(&trait_item.attrs);
-
let type_parameters = HasTypeParameters(&trait_item.generics,
TraitOrImplItemRibKind);
this.with_type_parameter_rib(type_parameters, |this| {
this.visit_generics(generics);
this.with_current_self_type(self_type, |this| {
for impl_item in impl_items {
- this.check_proc_macro_attrs(&impl_item.attrs);
this.resolve_visibility(&impl_item.vis);
// We also need a new scope for the impl item type parameters.
}
fn report_shadowing_errors(&mut self) {
- for (ident, scope) in replace(&mut self.lexical_macro_resolutions, Vec::new()) {
- self.resolve_legacy_scope(scope, ident, true);
- }
-
let mut reported_errors = FxHashSet();
for binding in replace(&mut self.disallowed_shadowing, Vec::new()) {
if self.resolve_legacy_scope(&binding.parent, binding.ident, false).is_some() &&
err.emit();
self.name_already_seen.insert(name, span);
}
-
- fn check_proc_macro_attrs(&mut self, attrs: &[ast::Attribute]) {
- if self.use_extern_macros { return; }
-
- for attr in attrs {
- if attr.path.segments.len() > 1 {
- continue
- }
- let ident = attr.path.segments[0].ident;
- let result = self.resolve_lexical_macro_path_segment(ident,
- MacroNS,
- false,
- false,
- true,
- attr.path.span);
- if let Ok(binding) = result {
- if let SyntaxExtension::AttrProcMacro(..) = *binding.binding().get_macro(self) {
- attr::mark_known(attr);
-
- let msg = "attribute procedural macros are experimental";
- let feature = "use_extern_macros";
-
- feature_err(&self.session.parse_sess, feature,
- attr.span, GateIssue::Language, msg)
- .span_label(binding.span(), "procedural macro imported here")
- .emit();
- }
- }
- }
- }
}
fn is_self_type(path: &[Ident], namespace: Namespace) -> bool {
use resolve_imports::ImportResolver;
use rustc::hir::def_id::{DefId, BUILTIN_MACROS_CRATE, CRATE_DEF_INDEX, DefIndex,
DefIndexAddressSpace};
-use rustc::hir::def::{Def, Export, NonMacroAttrKind};
+use rustc::hir::def::{Def, NonMacroAttrKind};
use rustc::hir::map::{self, DefCollector};
use rustc::{ty, lint};
use rustc::middle::cstore::CrateStore;
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 res = self.resolve_path(None, &path, Some(MacroNS), false, span, CrateLint::No);
let def = match res {
PathResult::NonModule(path_res) => match path_res.base_def() {
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 {
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;
}
_ => {
}
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);
let binding = if let Some(binding) = binding {
MacroBinding::Legacy(binding)
} else if let Some(binding) = self.macro_prelude.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)
}
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
let def = Def::Macro(def_id, MacroKind::Bang);
self.all_macros.insert(ident.name, def);
if attr::contains_name(&item.attrs, "macro_export") {
- if self.use_extern_macros {
- let module = self.graph_root;
- let vis = ty::Visibility::Public;
- self.define(module, ident, MacroNS,
- (def, vis, item.span, expansion, IsMacroExport));
- } else {
- self.macro_exports.push(Export {
- ident: ident.modern(),
- def: def,
- vis: ty::Visibility::Public,
- span: item.span,
- });
- }
+ let module = self.graph_root;
+ let vis = ty::Visibility::Public;
+ self.define(module, ident, MacroNS,
+ (def, vis, item.span, expansion, IsMacroExport));
} else {
self.unused_macros.insert(def_id);
}
use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::hir::def::*;
use rustc::session::DiagnosticMessageId;
-use rustc::util::nodemap::{FxHashMap, FxHashSet};
+use rustc::util::nodemap::FxHashSet;
use syntax::ast::{Ident, Name, NodeId, CRATE_NODE_ID};
use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
*module.globs.borrow_mut() = Vec::new();
let mut reexports = Vec::new();
- let mut exported_macro_names = FxHashMap();
- if ptr::eq(module, self.graph_root) {
- let macro_exports = mem::replace(&mut self.macro_exports, Vec::new());
- for export in macro_exports.into_iter().rev() {
- if let Some(later_span) = exported_macro_names.insert(export.ident.modern(),
- export.span) {
- self.session.buffer_lint_with_diagnostic(
- DUPLICATE_MACRO_EXPORTS,
- CRATE_NODE_ID,
- later_span,
- &format!("a macro named `{}` has already been exported", export.ident),
- BuiltinLintDiagnostics::DuplicatedMacroExports(
- export.ident, export.span, later_span));
- } else {
- reexports.push(export);
- }
- }
- }
for (&(ident, ns), resolution) in module.resolutions.borrow().iter() {
let resolution = &mut *resolution.borrow_mut();
if !def.def_id().is_local() {
self.cstore.export_macros_untracked(def.def_id().krate);
}
- if let Def::Macro(..) = def {
- if let Some(&span) = exported_macro_names.get(&ident.modern()) {
- let msg =
- format!("a macro named `{}` has already been exported", ident);
- self.session.struct_span_err(span, &msg)
- .span_label(span, format!("`{}` already exported", ident))
- .span_note(binding.span, "previous macro export here")
- .emit();
- }
- }
reexports.push(Export {
ident: ident.modern(),
def: def,
#![feature(unboxed_closures)]
#![feature(untagged_unions)]
#![feature(unwind_attributes)]
-#![feature(use_extern_macros)]
+#![cfg_attr(stage0, feature(use_extern_macros))]
#![feature(doc_cfg)]
#![feature(doc_masked)]
#![feature(doc_spotlight)]
return attrs;
}
- if self.cx.ecfg.use_extern_macros_enabled() {
- attr = find_attr_invoc(&mut attrs);
- }
+ attr = find_attr_invoc(&mut attrs);
traits = collect_derives(&mut self.cx, &mut attrs);
attrs
});
return attrs;
}
- if self.cx.ecfg.use_extern_macros_enabled() {
- attr = find_attr_invoc(&mut attrs);
- }
+ attr = find_attr_invoc(&mut attrs);
attrs
});
fn proc_macro_expr = proc_macro_expr,
fn proc_macro_non_items = proc_macro_non_items,
}
-
- pub fn use_extern_macros_enabled(&self) -> bool {
- self.features.map_or(false, |features| features.use_extern_macros())
- }
}
// A Marker adds the given mark to the syntax context.
{
$(f(stringify!($feature), self.$feature);)+
}
-
- pub fn use_extern_macros(&self) -> bool {
- // A number of "advanced" macro features enable
- // macro modularization (`use_extern_macros`) implicitly.
- self.use_extern_macros || self.decl_macro ||
- self.tool_attributes || self.custom_attribute ||
- self.macros_in_extern || self.proc_macro_path_invoc ||
- self.proc_macro_mod || self.proc_macro_expr ||
- self.proc_macro_non_items || self.proc_macro_gen ||
- self.stmt_expr_attributes || self.unrestricted_attribute_tokens
- }
}
};
// Allows #[link(..., cfg(..))]
(active, link_cfg, "1.14.0", Some(37406), None),
- (active, use_extern_macros, "1.15.0", Some(35896), Some(Edition::Edition2018)),
-
// `extern "ptx-*" fn()`
(active, abi_ptx, "1.15.0", Some(38788), None),
(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! (
(accepted, repr_transparent, "1.28.0", Some(43036), None),
// Defining procedural macros in `proc-macro` crates
(accepted, proc_macro, "1.29.0", Some(38356), None),
+ // Allows importing and reexporting macros with `use`,
+ // enables macro modularization in general.
+ (accepted, use_extern_macros, "1.30.0", Some(35896), None),
);
// If you change this, please modify src/doc/unstable-book as well. You must
// aux-build:attribute-with-error.rs
// ignore-stage1
-#![feature(use_extern_macros)]
-
extern crate attribute_with_error;
use attribute_with_error::foo;
// ignore-stage1
// compile-pass
-#![feature(use_extern_macros)]
#![warn(unused)]
extern crate attributes_included;
// FIXME: https://github.com/rust-lang/rust/issues/41430
// This is a temporary regression test for the ICE reported in #41211
-#![feature(use_extern_macros)]
#![emit_unchanged]
//~^ ERROR attribute `emit_unchanged` is currently unknown to the compiler
extern crate issue_41211;
// except according to those terms.
// aux-build:attr_proc_macro.rs
-#![feature(use_extern_macros)]
#[macro_use] extern crate attr_proc_macro;
// ignore-stage1
// ignore-wasm32
-#![feature(use_extern_macros)]
-
extern crate test_macros;
use test_macros::{nop_attr, no_output, emit_input};
// aux-build:more-gates.rs
-#![feature(use_extern_macros)]
-
extern crate more_gates as foo;
use foo::*;
// 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
// ignore-stage1
#![allow(warnings)]
-#![feature(use_extern_macros)]
extern crate attr_args;
use attr_args::{attr_with_args, identity};
// ignore-stage1
// revisions: foo bar
-#![feature(use_extern_macros)]
-
extern crate attr_cfg;
use attr_cfg::attr_cfg;
// aux-build:attr-on-trait.rs
// ignore-stage1
-#![feature(use_extern_macros)]
-
extern crate attr_on_trait;
use attr_on_trait::foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
-
extern crate hygiene_example_codegen;
pub use hygiene_example_codegen::hello;
// aux-build:derive-attr-cfg.rs
// ignore-stage1
-#![feature(use_extern_macros)]
-
extern crate derive_attr_cfg;
use derive_attr_cfg::Foo;
// aux-build:derive-two-attrs.rs
-#![feature(use_extern_macros)]
-
extern crate derive_two_attrs as foo;
use foo::A;
// aux-build:gen-lifetime-token.rs
-#![feature(use_extern_macros)]
-
extern crate gen_lifetime_token as bar;
bar::bar!();
// aux-build:issue-39889.rs
// ignore-stage1
-#![feature(use_extern_macros)]
-#![allow(unused)]
-
extern crate issue_39889;
use issue_39889::Issue39889;
// aux-build:lifetimes.rs
// ignore-stage1
-#![feature(use_extern_macros)]
-
extern crate lifetimes;
use lifetimes::*;
// aux-build:modify-ast.rs
-#![feature(use_extern_macros)]
-
extern crate modify_ast;
use modify_ast::*;
// aux-build:not-joint.rs
-#![feature(use_extern_macros)]
-
extern crate not_joint as bar;
use bar::{tokens, nothing};
// ignore-pretty
-#![feature(use_extern_macros)]
-
#[macro_use]
extern crate span_test_macros;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
#![allow(duplicate_macro_exports)]
#[macro_export]
// aux-build:two_macros.rs
-#![feature(use_extern_macros)]
-
extern crate two_macros;
::two_macros::macro_one!();
// aux-build:use-macro-self.rs
-#![feature(use_extern_macros)]
-
#[macro_use]
extern crate use_macro_self;
// aux-build:all-item-types.rs
// build-aux-docs
-#![feature(use_extern_macros)]
-
#![crate_name = "foo"]
#[macro_use]
// build-aux-docs
// ignore-cross-compile
-#![feature(use_extern_macros)]
-
#[macro_use] extern crate qwop;
// @has macro_vis/macro.some_macro.html
// build-aux-docs
#![feature(macro_test)]
-#![feature(use_extern_macros)]
#![crate_name = "foo"]
// aux-build:pub-use-extern-macros.rs
-#![feature(use_extern_macros)]
-
extern crate macros;
// @has pub_use_extern_macros/macro.bar.html
// aux-build:attribute-spans-preserved.rs
-#![feature(use_extern_macros)]
-
extern crate attribute_spans_preserved as foo;
use foo::foo;
error[E0308]: mismatched types
- --> $DIR/attribute-spans-preserved.rs:19:23
+ --> $DIR/attribute-spans-preserved.rs:17:23
|
LL | #[ foo ( let y: u32 = "z"; ) ] //~ ERROR: mismatched types
| ^^^ expected u32, found reference
found type `&'static str`
error[E0308]: mismatched types
- --> $DIR/attribute-spans-preserved.rs:20:23
+ --> $DIR/attribute-spans-preserved.rs:18:23
|
LL | #[ bar { let x: u32 = "y"; } ] //~ ERROR: mismatched types
| ^^^ expected u32, found reference
// aux-build:macro-brackets.rs
-#![feature(use_extern_macros)]
-
extern crate macro_brackets as bar;
use bar::doit;
error[E0308]: mismatched types
- --> $DIR/macro-brackets.rs:23:21
+ --> $DIR/macro-brackets.rs:21:21
|
LL | id![static X: u32 = 'a';]; //~ ERROR: mismatched types
| ^^^ expected u32, found char
// no-prefer-dynamic
-#![feature(use_extern_macros)]
#![crate_type = "proc-macro"]
extern crate proc_macro;
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:35:5
+ --> $DIR/macro-namespace-reserved-2.rs:34:5
|
LL | my_macro!(); //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:38:5
+ --> $DIR/macro-namespace-reserved-2.rs:37:5
|
LL | my_macro_attr!(); //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:41:5
+ --> $DIR/macro-namespace-reserved-2.rs:40:5
|
LL | MyTrait!(); //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:44:1
+ --> $DIR/macro-namespace-reserved-2.rs:43:1
|
LL | #[my_macro] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:46:1
+ --> $DIR/macro-namespace-reserved-2.rs:45:1
|
LL | #[my_macro_attr] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:48:1
+ --> $DIR/macro-namespace-reserved-2.rs:47:1
|
LL | #[MyTrait] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:51:10
+ --> $DIR/macro-namespace-reserved-2.rs:50:10
|
LL | #[derive(my_macro)] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:53:10
+ --> $DIR/macro-namespace-reserved-2.rs:52:10
|
LL | #[derive(my_macro_attr)] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^^^^^^^
error: can't use a procedural macro from the same crate that defines it
- --> $DIR/macro-namespace-reserved-2.rs:55:10
+ --> $DIR/macro-namespace-reserved-2.rs:54:10
|
LL | #[derive(MyTrait)] //~ ERROR can't use a procedural macro from the same crate that defines it
| ^^^^^^^
// aux-build:nested-item-spans.rs
-#![feature(use_extern_macros)]
-
extern crate nested_item_spans;
use nested_item_spans::foo;
error[E0308]: mismatched types
- --> $DIR/nested-item-spans.rs:22:22
+ --> $DIR/nested-item-spans.rs:20:22
|
LL | let x: u32 = "x"; //~ ERROR: mismatched types
| ^^^ expected u32, found reference
found type `&'static str`
error[E0308]: mismatched types
- --> $DIR/nested-item-spans.rs:31:22
+ --> $DIR/nested-item-spans.rs:29:22
|
LL | let x: u32 = "x"; //~ ERROR: mismatched types
| ^^^ expected u32, found reference
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
-
pub use std::panic;
#[macro_export]
error[E0255]: the name `panic` is defined multiple times
- --> $DIR/duplicate-check-macro-exports.rs:16:1
+ --> $DIR/duplicate-check-macro-exports.rs:14:1
|
LL | pub use std::panic;
| ---------- previous import of the macro `panic` here
// #41719
-#![feature(use_extern_macros)]
-
fn main() {
enum Foo {}
let _ = Foo::bar!(); //~ ERROR fail to resolve non-ident macro path
error: fail to resolve non-ident macro path
- --> $DIR/extern-macro.rs:17:13
+ --> $DIR/extern-macro.rs:15:13
|
LL | let _ = Foo::bar!(); //~ ERROR fail to resolve non-ident macro path
| ^^^^^^^^
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
-
fn main() {
#[rustfmt::skip] //~ ERROR tool attributes are unstable
let x = 3
error[E0658]: tool attributes are unstable (see issue #44690)
- --> $DIR/feature-gate-tool_attributes.rs:14:5
+ --> $DIR/feature-gate-tool_attributes.rs:12:5
|
LL | #[rustfmt::skip] //~ ERROR tool attributes are unstable
| ^^^^^^^^^^^^^^^^
// compile-pass
// aux-build:local_inner_macros.rs
-#![feature(use_extern_macros)]
-
extern crate local_inner_macros;
use local_inner_macros::{public_macro, public_macro_dynamic};
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// `local_inner_macros` has no effect if `feature(use_extern_macros)` is not enabled
-
-// aux-build:local_inner_macros.rs
-
-#[macro_use(public_macro)]
-extern crate local_inner_macros;
-
-public_macro!(); //~ ERROR cannot find macro `helper2!` in this scope
-
-fn main() {}
+++ /dev/null
-error: cannot find macro `helper2!` in this scope
- --> $DIR/local_inner_macros_disabled.rs:18:1
- |
-LL | public_macro!(); //~ ERROR cannot find macro `helper2!` in this scope
- | ^^^^^^^^^^^^^^^^
- |
- = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-
-error: aborting due to previous error
-
// Crate-local macro expanded `macro_export` macros cannot be accessed with module-relative paths.
-#![feature(use_extern_macros)]
-
macro_rules! define_exported { () => {
#[macro_export]
macro_rules! exported {
error: macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
- --> $DIR/local-modularized-tricky-fail-3.rs:25:9
+ --> $DIR/local-modularized-tricky-fail-3.rs:23:9
|
LL | use exported;
| ^^^^^^^^
|
note: the macro is defined here
- --> $DIR/local-modularized-tricky-fail-3.rs:17:5
+ --> $DIR/local-modularized-tricky-fail-3.rs:15:5
|
LL | / macro_rules! exported {
LL | | () => ()
| ------------------- in this macro invocation
error: macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
- --> $DIR/local-modularized-tricky-fail-3.rs:30:5
+ --> $DIR/local-modularized-tricky-fail-3.rs:28:5
|
LL | ::exported!();
| ^^^^^^^^^^
|
note: the macro is defined here
- --> $DIR/local-modularized-tricky-fail-3.rs:17:5
+ --> $DIR/local-modularized-tricky-fail-3.rs:15:5
|
LL | / macro_rules! exported {
LL | | () => ()
// compile-pass
-#![feature(use_extern_macros)]
-
macro_rules! define_exported { () => {
#[macro_export]
macro_rules! exported {
// compile-pass
-#![feature(use_extern_macros)]
-
#[macro_export(local_inner_macros)]
macro_rules! dollar_crate_exported {
(1) => { $crate::exported!(); };
// aux-build:two_macros.rs
-#![feature(use_extern_macros)]
-
extern crate two_macros;
mod foo {
error[E0659]: `bar` is ambiguous
- --> $DIR/macro-paths.rs:25:5
+ --> $DIR/macro-paths.rs:23:5
|
LL | bar::m! { //~ ERROR ambiguous
| ^^^^^^
|
note: `bar` could refer to the name defined here
- --> $DIR/macro-paths.rs:26:9
+ --> $DIR/macro-paths.rs:24:9
|
LL | mod bar { pub use two_macros::m; }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `bar` could also refer to the name imported here
- --> $DIR/macro-paths.rs:24:9
+ --> $DIR/macro-paths.rs:22:9
|
LL | use foo::*;
| ^^^^^^
= note: macro-expanded items do not shadow when used in a macro invocation path
error[E0659]: `baz` is ambiguous
- --> $DIR/macro-paths.rs:35:5
+ --> $DIR/macro-paths.rs:33:5
|
LL | baz::m! { //~ ERROR ambiguous
| ^^^^^^
|
note: `baz` could refer to the name defined here
- --> $DIR/macro-paths.rs:36:9
+ --> $DIR/macro-paths.rs:34:9
|
LL | mod baz { pub use two_macros::m; }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `baz` could also refer to the name defined here
- --> $DIR/macro-paths.rs:30:1
+ --> $DIR/macro-paths.rs:28:1
|
LL | / pub mod baz {
LL | | pub use two_macros::m;
// aux-build:two_macros.rs
-#![feature(use_extern_macros)]
-
extern crate two_macros; // two identity macros `m` and `n`
mod foo {
error: `m` is ambiguous
- --> $DIR/macros.rs:50:5
+ --> $DIR/macros.rs:48:5
|
LL | m!(); //~ ERROR ambiguous
| ^
|
note: `m` could refer to the macro defined here
- --> $DIR/macros.rs:48:5
+ --> $DIR/macros.rs:46:5
|
LL | macro_rules! m { () => {} }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `m` could also refer to the macro imported here
- --> $DIR/macros.rs:49:9
+ --> $DIR/macros.rs:47:9
|
LL | use two_macros::m;
| ^^^^^^^^^^^^^
error[E0659]: `m` is ambiguous
- --> $DIR/macros.rs:28:5
+ --> $DIR/macros.rs:26:5
|
LL | m! { //~ ERROR ambiguous
| ^
|
note: `m` could refer to the name imported here
- --> $DIR/macros.rs:29:13
+ --> $DIR/macros.rs:27:13
|
LL | use foo::m;
| ^^^^^^
note: `m` could also refer to the name imported here
- --> $DIR/macros.rs:27:9
+ --> $DIR/macros.rs:25:9
|
LL | use two_macros::*;
| ^^^^^^^^^^^^^
= note: macro-expanded macro imports do not shadow
error[E0659]: `m` is ambiguous
- --> $DIR/macros.rs:41:9
+ --> $DIR/macros.rs:39:9
|
LL | m! { //~ ERROR ambiguous
| ^
|
note: `m` could refer to the name imported here
- --> $DIR/macros.rs:42:17
+ --> $DIR/macros.rs:40:17
|
LL | use two_macros::n as m;
| ^^^^^^^^^^^^^^^^^^
note: `m` could also refer to the name imported here
- --> $DIR/macros.rs:34:9
+ --> $DIR/macros.rs:32:9
|
LL | use two_macros::m;
| ^^^^^^^^^^^^^
// aux-build:two_macros.rs
-#![feature(use_extern_macros)]
-
mod foo {
extern crate two_macros;
pub use self::two_macros::m as panic;
error: `panic` is already in scope
- --> $DIR/shadow_builtin_macros.rs:42:9
+ --> $DIR/shadow_builtin_macros.rs:40:9
|
LL | macro_rules! panic { () => {} } //~ ERROR `panic` is already in scope
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: macro-expanded `macro_rules!`s may not shadow existing macros (see RFC 1560)
error[E0659]: `panic` is ambiguous
- --> $DIR/shadow_builtin_macros.rs:27:14
+ --> $DIR/shadow_builtin_macros.rs:25:14
|
LL | fn f() { panic!(); } //~ ERROR ambiguous
| ^^^^^
|
note: `panic` could refer to the name imported here
- --> $DIR/shadow_builtin_macros.rs:26:9
+ --> $DIR/shadow_builtin_macros.rs:24:9
|
LL | use foo::*;
| ^^^^^^
= note: consider adding an explicit import of `panic` to disambiguate
error[E0659]: `panic` is ambiguous
- --> $DIR/shadow_builtin_macros.rs:32:14
+ --> $DIR/shadow_builtin_macros.rs:30:14
|
LL | fn f() { panic!(); } //~ ERROR ambiguous
| ^^^^^
|
note: `panic` could refer to the name imported here
- --> $DIR/shadow_builtin_macros.rs:31:26
+ --> $DIR/shadow_builtin_macros.rs:29:26
|
LL | ::two_macros::m!(use foo::panic;);
| ^^^^^^^^^^
= note: macro-expanded macro imports do not shadow
error[E0659]: `n` is ambiguous
- --> $DIR/shadow_builtin_macros.rs:61:5
+ --> $DIR/shadow_builtin_macros.rs:59:5
|
LL | n!(); //~ ERROR ambiguous
| ^
|
note: `n` could refer to the name imported here
- --> $DIR/shadow_builtin_macros.rs:60:9
+ --> $DIR/shadow_builtin_macros.rs:58:9
|
LL | use bar::*;
| ^^^^^^
note: `n` could also refer to the name imported here
- --> $DIR/shadow_builtin_macros.rs:48:13
+ --> $DIR/shadow_builtin_macros.rs:46:13
|
LL | #[macro_use(n)]
| ^
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros, extern_prelude)]
+#![feature(extern_prelude)]
mod m {
fn check() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
-
mod m {
fn check() {
Result::Ok!(); //~ ERROR fail to resolve non-ident macro path
error: fail to resolve non-ident macro path
- --> $DIR/macro-path-prelude-fail-2.rs:15:9
+ --> $DIR/macro-path-prelude-fail-2.rs:13:9
|
LL | Result::Ok!(); //~ ERROR fail to resolve non-ident macro path
| ^^^^^^^^^^
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(use_extern_macros)]
-
#[derive(inline)] //~ ERROR cannot find derive macro `inline` in this scope
struct S;
error: cannot find derive macro `inline` in this scope
- --> $DIR/macro-path-prelude-fail-3.rs:13:10
+ --> $DIR/macro-path-prelude-fail-3.rs:11:10
|
LL | #[derive(inline)] //~ ERROR cannot find derive macro `inline` in this scope
| ^^^^^^
error: cannot find macro `inline!` in this scope
- --> $DIR/macro-path-prelude-fail-3.rs:17:5
+ --> $DIR/macro-path-prelude-fail-3.rs:15:5
|
LL | inline!(); //~ ERROR cannot find macro `inline!` in this scope
| ^^^^^^ help: you could try the macro: `line`
// compile-pass
-#![feature(use_extern_macros, extern_prelude)]
+#![feature(extern_prelude)]
mod m {
fn check() {
LL | #![feature(macro_reexport)] //~ ERROR feature has been removed
| ^^^^^^^^^^^^^^
|
-note: subsumed by `#![feature(use_extern_macros)]` and `pub use`
+note: subsumed by `pub use`
--> $DIR/macro-reexport-removed.rs:13:12
|
LL | #![feature(macro_reexport)] //~ ERROR feature has been removed
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// gate-test-use_extern_macros
-
-fn main() {
- globnar::brotz!(); //~ ERROR non-ident macro paths are experimental
-}
+++ /dev/null
-error[E0658]: non-ident macro paths are experimental (see issue #35896)
- --> $DIR/macro-with-seps-err-msg.rs:14:5
- |
-LL | globnar::brotz!(); //~ ERROR non-ident macro paths are experimental
- | ^^^^^^^^^^^^^^
- |
- = help: add #![feature(use_extern_macros)] to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
fn main() {
k!(); //~ ERROR cannot find
- kl!(); //~ ERROR cannot find
+ kl!();
}
-error: cannot find macro `kl!` in this scope
- --> $DIR/macro_undefined.rs:22:5
- |
-LL | kl!(); //~ ERROR cannot find
- | ^^
- |
- = help: have you added the `#[macro_use]` on the module/import?
-
error: cannot find macro `k!` in this scope
--> $DIR/macro_undefined.rs:21:5
|
LL | k!(); //~ ERROR cannot find
| ^ help: you could try the macro: `kl`
-error: aborting due to 2 previous errors
+error: aborting due to previous error
env!(foo, abr, baz); //~ ERROR
env!("RUST_HOPEFULLY_THIS_DOESNT_EXIST"); //~ ERROR
- foo::blah!(); //~ ERROR
-
format!(invalid); //~ ERROR
include!(invalid); //~ ERROR
LL | env!("RUST_HOPEFULLY_THIS_DOESNT_EXIST"); //~ ERROR
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error[E0658]: non-ident macro paths are experimental (see issue #35896)
- --> $DIR/macros-nonfatal-errors.rs:33:5
- |
-LL | foo::blah!(); //~ ERROR
- | ^^^^^^^^^
- |
- = help: add #![feature(use_extern_macros)] to the crate attributes to enable
-
error: format argument must be a string literal
- --> $DIR/macros-nonfatal-errors.rs:35:13
+ --> $DIR/macros-nonfatal-errors.rs:33:13
|
LL | format!(invalid); //~ ERROR
| ^^^^^^^
| ^^^^^
error: argument must be a string literal
- --> $DIR/macros-nonfatal-errors.rs:37:14
+ --> $DIR/macros-nonfatal-errors.rs:35:14
|
LL | include!(invalid); //~ ERROR
| ^^^^^^^
error: argument must be a string literal
- --> $DIR/macros-nonfatal-errors.rs:39:18
+ --> $DIR/macros-nonfatal-errors.rs:37:18
|
LL | include_str!(invalid); //~ ERROR
| ^^^^^^^
error: couldn't read $DIR/i'd be quite surprised if a file with this name existed: No such file or directory (os error 2)
- --> $DIR/macros-nonfatal-errors.rs:40:5
+ --> $DIR/macros-nonfatal-errors.rs:38:5
|
LL | include_str!("i'd be quite surprised if a file with this name existed"); //~ ERROR
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: argument must be a string literal
- --> $DIR/macros-nonfatal-errors.rs:41:20
+ --> $DIR/macros-nonfatal-errors.rs:39:20
|
LL | include_bytes!(invalid); //~ ERROR
| ^^^^^^^
error: couldn't read $DIR/i'd be quite surprised if a file with this name existed: No such file or directory (os error 2)
- --> $DIR/macros-nonfatal-errors.rs:42:5
+ --> $DIR/macros-nonfatal-errors.rs:40:5
|
LL | include_bytes!("i'd be quite surprised if a file with this name existed"); //~ ERROR
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: trace_macros! accepts only `true` or `false`
- --> $DIR/macros-nonfatal-errors.rs:44:5
+ --> $DIR/macros-nonfatal-errors.rs:42:5
|
LL | trace_macros!(invalid); //~ ERROR
| ^^^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 15 previous errors
+error: aborting due to 14 previous errors
-Some errors occurred: E0658, E0665.
-For more information about an error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0665`.
#[no_link]
extern crate empty_struct;
-//~^ WARN proc macro crates and `#[no_link]` crates have no effect without `#[macro_use]`
fn main() {
empty_struct::XEmpty1; //~ ERROR cannot find value `XEmpty1` in module `empty_struct`
-warning: proc macro crates and `#[no_link]` crates have no effect without `#[macro_use]`
- --> $DIR/no-link.rs:14:1
- |
-LL | extern crate empty_struct;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
error[E0425]: cannot find value `XEmpty1` in module `empty_struct`
- --> $DIR/no-link.rs:18:19
+ --> $DIR/no-link.rs:17:19
|
LL | empty_struct::XEmpty1; //~ ERROR cannot find value `XEmpty1` in module `empty_struct`
| ^^^^^^^ not found in `empty_struct`
// compile-pass
#![warn(macro_use_extern_crate, unused)]
-#![feature(use_extern_macros)]
#[macro_use] //~ WARN should be replaced at use sites with a `use` statement
extern crate macro_use_warned_against;
warning: deprecated `#[macro_use]` directive used to import macros should be replaced at use sites with a `use` statement to import the macro instead
- --> $DIR/macro-use-warned-against.rs:18:1
+ --> $DIR/macro-use-warned-against.rs:17:1
|
LL | #[macro_use] //~ WARN should be replaced at use sites with a `use` statement
| ^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^
warning: unused `#[macro_use]` import
- --> $DIR/macro-use-warned-against.rs:20:1
+ --> $DIR/macro-use-warned-against.rs:19:1
|
LL | #[macro_use] //~ WARN unused `#[macro_use]`
| ^^^^^^^^^^^^
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// If macro modularization (`use_extern_macros`) is not enabled,
-// then tool attributes are treated as custom attributes.
-
-#[rustfmt::bar] //~ ERROR The attribute `rustfmt::bar` is currently unknown to the compiler
-fn main() {}
+++ /dev/null
-error[E0658]: The attribute `rustfmt::bar` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
- --> $DIR/tool-attributes-disabled-1.rs:14:1
- |
-LL | #[rustfmt::bar] //~ ERROR The attribute `rustfmt::bar` is currently unknown to the compiler
- | ^^^^^^^^^^^^^^^
- |
- = help: add #![feature(custom_attribute)] to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// If macro modularization (`use_extern_macros`) is not enabled,
-// then tool attributes are treated as custom attributes.
-
-#[rustfmt::bar] //~ ERROR attribute `rustfmt::bar` is currently unknown to the compiler
-fn main() {}
+++ /dev/null
-error[E0658]: The attribute `rustfmt::bar` is currently unknown to the compiler and may have meaning added to it in the future (see issue #29642)
- --> $DIR/tool-attributes-disabled-2.rs:14:1
- |
-LL | #[rustfmt::bar] //~ ERROR attribute `rustfmt::bar` is currently unknown to the compiler
- | ^^^^^^^^^^^^^^^
- |
- = help: add #![feature(custom_attribute)] to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
projects / rust.git / commitdiff