bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

resolve: Improve diagnostics for resolution ambiguities

Browse source
This commit is contained in:
Vadim Petrochenkov 2018-11-05 01:11:59 +03:00
parent 9d7d9ada6d
commit f0ea1c6f1e
41 changed files with 603 additions and 425 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/librustc/hir/def.rs
View file

@ -128,14 +128,6 @@ impl PathResolution {
pub fn unresolved_segments(&self) -> usize { pub fn unresolved_segments(&self) -> usize {
self.unresolved_segments self.unresolved_segments
} }
pub fn kind_name(&self) -> &'static str {
if self.unresolved_segments != 0 {
"associated item"
} else {
self.base_def.kind_name()
}
}
} }
/// Different kinds of symbols don't influence each other. /// Different kinds of symbols don't influence each other.
@ -333,4 +325,12 @@ impl Def {
Def::Err => "unresolved item", Def::Err => "unresolved item",
} }
} }
pub fn article(&self) -> &'static str {
match *self {
Def::AssociatedTy(..) | Def::AssociatedConst(..) | Def::AssociatedExistential(..) |
Def::Enum(..) | Def::Existential(..) | Def::Err => "an",
_ => "a",
}
}
} }

3
src/librustc_mir/hair/pattern/check_match.rs
View file

@ -298,7 +298,8 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
let label_msg = match pat.node { let label_msg = match pat.node {
PatKind::Path(hir::QPath::Resolved(None, ref path)) PatKind::Path(hir::QPath::Resolved(None, ref path))
if path.segments.len() == 1 && path.segments[0].args.is_none() => { if path.segments.len() == 1 && path.segments[0].args.is_none() => {
format!("interpreted as a {} pattern, not new variable", path.def.kind_name()) format!("interpreted as {} {} pattern, not new variable",
path.def.article(), path.def.kind_name())
} }
_ => format!("pattern `{}` not covered", pattern_string), _ => format!("pattern `{}` not covered", pattern_string),
}; };

38
src/librustc_resolve/build_reduced_graph.rs
View file

@ -347,25 +347,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
let used = self.process_legacy_macro_imports(item, module, &parent_scope); let used = self.process_legacy_macro_imports(item, module, &parent_scope);
let binding = let binding =
(module, ty::Visibility::Public, sp, expansion).to_name_binding(self.arenas); (module, ty::Visibility::Public, sp, expansion).to_name_binding(self.arenas);
if ptr::eq(self.current_module, self.graph_root) {
if let Some(entry) = self.extern_prelude.get(&ident.modern()) {
if expansion != Mark::root() && orig_name.is_some() &&
entry.extern_crate_item.is_none() {
self.session.span_err(item.span, "macro-expanded `extern crate` items \
cannot shadow names passed with \
`--extern`");
}
}
let entry = self.extern_prelude.entry(ident.modern())
.or_insert(ExternPreludeEntry {
extern_crate_item: None,
introduced_by_item: true,
});
entry.extern_crate_item = Some(binding);
if orig_name.is_some() {
entry.introduced_by_item = true;
}
}
let directive = self.arenas.alloc_import_directive(ImportDirective { let directive = self.arenas.alloc_import_directive(ImportDirective {
root_id: item.id, root_id: item.id,
id: item.id, id: item.id,
@ -383,6 +364,25 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
}); });
self.potentially_unused_imports.push(directive); self.potentially_unused_imports.push(directive);
let imported_binding = self.import(binding, directive); let imported_binding = self.import(binding, directive);
if ptr::eq(self.current_module, self.graph_root) {
if let Some(entry) = self.extern_prelude.get(&ident.modern()) {
if expansion != Mark::root() && orig_name.is_some() &&
entry.extern_crate_item.is_none() {
self.session.span_err(item.span, "macro-expanded `extern crate` items \
cannot shadow names passed with \
`--extern`");
}
}
let entry = self.extern_prelude.entry(ident.modern())
.or_insert(ExternPreludeEntry {
extern_crate_item: None,
introduced_by_item: true,
});
entry.extern_crate_item = Some(imported_binding);
if orig_name.is_some() {
entry.introduced_by_item = true;
}
}
self.define(parent, ident, TypeNS, imported_binding); self.define(parent, ident, TypeNS, imported_binding);
} }

184
src/librustc_resolve/lib.rs
View file

@ -391,14 +391,13 @@ fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver,
err err
} }
ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => { ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => {
let shadows_what = PathResolution::new(binding.def()).kind_name(); let (shadows_what, article) = (binding.descr(), binding.article());
let mut err = struct_span_err!(resolver.session, let mut err = struct_span_err!(resolver.session, span, E0530, "{}s cannot shadow {}s",
span, what_binding, shadows_what);
E0530, err.span_label(span, format!("cannot be named the same as {} {}",
"{}s cannot shadow {}s", what_binding, shadows_what); article, shadows_what));
err.span_label(span, format!("cannot be named the same as a {}", shadows_what));
let participle = if binding.is_import() { "imported" } else { "defined" }; let participle = if binding.is_import() { "imported" } else { "defined" };
let msg = format!("a {} `{}` is {} here", shadows_what, name, participle); let msg = format!("{} {} `{}` is {} here", article, shadows_what, name, participle);
err.span_label(binding.span, msg); err.span_label(binding.span, msg);
err err
} }
@ -1195,6 +1194,7 @@ enum NameBindingKind<'a> {
used: Cell<bool>, used: Cell<bool>,
}, },
Ambiguity { Ambiguity {
kind: AmbiguityKind,
b1: &'a NameBinding<'a>, b1: &'a NameBinding<'a>,
b2: &'a NameBinding<'a>, b2: &'a NameBinding<'a>,
} }
@ -1212,10 +1212,61 @@ struct UseError<'a> {
better: bool, better: bool,
} }
#[derive(Clone, Copy, PartialEq, Debug)]
enum AmbiguityKind {
Import,
BuiltinAttr,
DeriveHelper,
LegacyHelperVsPrelude,
LegacyVsModern,
GlobVsOuter,
GlobVsGlob,
GlobVsExpanded,
MoreExpandedVsOuter,
}
impl AmbiguityKind {
fn descr(self) -> &'static str {
match self {
AmbiguityKind::Import =>
"name vs any other name during import resolution",
AmbiguityKind::BuiltinAttr =>
"built-in attribute vs any other name",
AmbiguityKind::DeriveHelper =>
"derive helper attribute vs any other name",
AmbiguityKind::LegacyHelperVsPrelude =>
"legacy plugin helper attribute vs name from prelude",
AmbiguityKind::LegacyVsModern =>
"`macro_rules` vs non-`macro_rules` from other module",
AmbiguityKind::GlobVsOuter =>
"glob import vs any other name from outer scope during import/macro resolution",
AmbiguityKind::GlobVsGlob =>
"glob import vs glob import in the same module",
AmbiguityKind::GlobVsExpanded =>
"glob import vs macro-expanded name in the same \
module during import/macro resolution",
AmbiguityKind::MoreExpandedVsOuter =>
"macro-expanded name vs less macro-expanded name \
from outer scope during import/macro resolution",
}
}
}
/// Miscellaneous bits of metadata for better ambiguity error reporting.
#[derive(Clone, Copy, PartialEq)]
enum AmbiguityErrorMisc {
SuggestSelf,
FromPrelude,
None,
}
struct AmbiguityError<'a> { struct AmbiguityError<'a> {
kind: AmbiguityKind,
ident: Ident, ident: Ident,
b1: &'a NameBinding<'a>, b1: &'a NameBinding<'a>,
b2: &'a NameBinding<'a>, b2: &'a NameBinding<'a>,
misc1: AmbiguityErrorMisc,
misc2: AmbiguityErrorMisc,
} }
impl<'a> NameBinding<'a> { impl<'a> NameBinding<'a> {
@ -1268,6 +1319,9 @@ impl<'a> NameBinding<'a> {
subclass: ImportDirectiveSubclass::ExternCrate { .. }, .. subclass: ImportDirectiveSubclass::ExternCrate { .. }, ..
}, .. }, ..
} => true, } => true,
NameBindingKind::Module(
&ModuleData { kind: ModuleKind::Def(Def::Mod(def_id), _), .. }
) => def_id.index == CRATE_DEF_INDEX,
_ => false, _ => false,
} }
} }
@ -1313,6 +1367,10 @@ impl<'a> NameBinding<'a> {
if self.is_extern_crate() { "extern crate" } else { self.def().kind_name() } if self.is_extern_crate() { "extern crate" } else { self.def().kind_name() }
} }
fn article(&self) -> &'static str {
if self.is_extern_crate() { "an" } else { self.def().article() }
}
// Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding` // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
// at some expansion round `max(invoc, binding)` when they both emerged from macros. // at some expansion round `max(invoc, binding)` when they both emerged from macros.
// Then this function returns `true` if `self` may emerge from a macro *after* that // Then this function returns `true` if `self` may emerge from a macro *after* that
@ -1885,8 +1943,12 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
self.record_use(ident, ns, binding) self.record_use(ident, ns, binding)
} }
NameBindingKind::Import { .. } => false, NameBindingKind::Import { .. } => false,
NameBindingKind::Ambiguity { b1, b2 } => { NameBindingKind::Ambiguity { kind, b1, b2 } => {
self.ambiguity_errors.push(AmbiguityError { ident, b1, b2 }); self.ambiguity_errors.push(AmbiguityError {
kind, ident, b1, b2,
misc1: AmbiguityErrorMisc::None,
misc2: AmbiguityErrorMisc::None,
});
true true
} }
_ => false _ => false
@ -2024,7 +2086,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
} }
if ns == TypeNS && is_known_tool(ident.name) { if ns == TypeNS && is_known_tool(ident.name) {
let binding = (Def::ToolMod, ty::Visibility::Public, let binding = (Def::ToolMod, ty::Visibility::Public,
ident.span, Mark::root()).to_name_binding(self.arenas); DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
return Some(LexicalScopeBinding::Item(binding)); return Some(LexicalScopeBinding::Item(binding));
} }
if let Some(prelude) = self.prelude { if let Some(prelude) = self.prelude {
@ -4631,37 +4693,79 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
} }
} }
fn report_ambiguity_error(&self, ident: Ident, b1: &NameBinding, b2: &NameBinding) { fn report_ambiguity_error(&self, ambiguity_error: &AmbiguityError) {
let participle = |is_import: bool| if is_import { "imported" } else { "defined" }; let AmbiguityError { kind, ident, b1, b2, misc1, misc2 } = *ambiguity_error;
let msg1 = let (b1, b2, misc1, misc2, swapped) = if b2.span.is_dummy() && !b1.span.is_dummy() {
format!("`{}` could refer to the name {} here", ident, participle(b1.is_import())); // We have to print the span-less alternative first, otherwise formatting looks bad.
let msg2 = (b2, b1, misc2, misc1, true)
format!("`{}` could also refer to the name {} here", ident, participle(b2.is_import()));
let note = if b1.expansion != Mark::root() {
Some(if let Def::Macro(..) = b1.def() {
format!("macro-expanded {} do not shadow",
if b1.is_import() { "macro imports" } else { "macros" })
} else {
format!("macro-expanded {} do not shadow when used in a macro invocation path",
if b1.is_import() { "imports" } else { "items" })
})
} else if b1.is_glob_import() {
Some(format!("consider adding an explicit import of `{}` to disambiguate", ident))
} else { } else {
None (b1, b2, misc1, misc2, false)
}; };
let mut err = struct_span_err!(self.session, ident.span, E0659, "`{}` is ambiguous", ident); let mut err = struct_span_err!(self.session, ident.span, E0659,
"`{ident}` is ambiguous ({why})",
ident = ident, why = kind.descr());
err.span_label(ident.span, "ambiguous name"); err.span_label(ident.span, "ambiguous name");
err.span_note(b1.span, &msg1);
match b2.def() { let mut could_refer_to = |b: &NameBinding, misc: AmbiguityErrorMisc, also: &str| {
Def::Macro(..) if b2.span.is_dummy() => let what = if b.span.is_dummy() {
err.note(&format!("`{}` is also a builtin macro", ident)), let add_built_in = match b.def() {
_ => err.span_note(b2.span, &msg2), // These already contain the "built-in" prefix or look bad with it.
Def::NonMacroAttr(..) | Def::PrimTy(..) | Def::ToolMod => false,
_ => true,
};
let (built_in, from) = if misc == AmbiguityErrorMisc::FromPrelude {
("", " from prelude")
} else if b.is_extern_crate() && !b.is_import() &&
self.session.opts.externs.get(&ident.as_str()).is_some() {
("", " passed with `--extern`")
} else if add_built_in {
(" built-in", "")
} else {
("", "")
};
let article = if built_in.is_empty() { b.article() } else { "a" };
format!("{a}{built_in} {thing}{from}",
a = article, thing = b.descr(), built_in = built_in, from = from)
} else {
let participle = if b.is_import() { "imported" } else { "defined" };
format!("the {thing} {introduced} here",
thing = b.descr(), introduced = participle)
};
let note_msg = format!("`{ident}` could{also} refer to {what}",
ident = ident, also = also, what = what);
let mut help_msgs = Vec::new();
if b.is_glob_import() && (kind == AmbiguityKind::GlobVsGlob ||
kind == AmbiguityKind::GlobVsExpanded ||
kind == AmbiguityKind::GlobVsOuter &&
swapped != also.is_empty()) {
help_msgs.push(format!("consider adding an explicit import of \
`{ident}` to disambiguate", ident = ident))
}
if b.is_extern_crate() && self.session.rust_2018() {
help_msgs.push(format!("use `::{ident}` to refer to the {thing} unambiguously",
ident = ident, thing = b.descr()))
}
if misc == AmbiguityErrorMisc::SuggestSelf {
help_msgs.push(format!("use `self::{ident}` to refer to the {thing} unambiguously",
ident = ident, thing = b.descr()))
}
if b.span.is_dummy() {
err.note(&note_msg);
} else {
err.span_note(b.span, &note_msg);
}
for (i, help_msg) in help_msgs.iter().enumerate() {
let or = if i == 0 { "" } else { "or " };
err.help(&format!("{}{}", or, help_msg));
}
}; };
if let Some(note) = note {
err.note(&note); could_refer_to(b1, misc1, "");
} could_refer_to(b2, misc2, " also");
err.emit(); err.emit();
} }
@ -4680,9 +4784,9 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
); );
} }
for &AmbiguityError { ident, b1, b2 } in &self.ambiguity_errors { for ambiguity_error in &self.ambiguity_errors {
if reported_spans.insert(ident.span) { if reported_spans.insert(ambiguity_error.ident.span) {
self.report_ambiguity_error(ident, b1, b2); self.report_ambiguity_error(ambiguity_error);
} }
} }
@ -4860,7 +4964,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
}; };
let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX }); let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
self.populate_module_if_necessary(&crate_root); self.populate_module_if_necessary(&crate_root);
Some((crate_root, ty::Visibility::Public, ident.span, Mark::root()) Some((crate_root, ty::Visibility::Public, DUMMY_SP, Mark::root())
.to_name_binding(self.arenas)) .to_name_binding(self.arenas))
} }
}) })

122
src/librustc_resolve/macros.rs
View file

@ -8,8 +8,9 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use {AmbiguityError, CrateLint, Resolver, ResolutionError, is_known_tool, resolve_error}; use {AmbiguityError, AmbiguityKind, AmbiguityErrorMisc};
use {Module, ModuleKind, NameBinding, NameBindingKind, PathResult, Segment, ToNameBinding}; use {CrateLint, Resolver, ResolutionError, is_known_tool, resolve_error};
use {Module, ModuleKind, NameBinding, NameBindingKind, PathResult, ToNameBinding};
use ModuleOrUniformRoot; use ModuleOrUniformRoot;
use Namespace::{self, *}; use Namespace::{self, *};
use build_reduced_graph::{BuildReducedGraphVisitor, IsMacroExport}; use build_reduced_graph::{BuildReducedGraphVisitor, IsMacroExport};
@ -597,10 +598,11 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
bitflags! { bitflags! {
struct Flags: u8 { struct Flags: u8 {
const DERIVE_HELPERS = 1 << 0; const MACRO_RULES = 1 << 0;
const MACRO_RULES = 1 << 1; const MODULE = 1 << 1;
const MODULE = 1 << 2; const PRELUDE = 1 << 2;
const PRELUDE = 1 << 3; const MISC_SUGGEST_SELF = 1 << 3;
const MISC_FROM_PRELUDE = 1 << 4;
} }
} }
@ -619,7 +621,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
// } // }
// So we have to save the innermost solution and continue searching in outer scopes // So we have to save the innermost solution and continue searching in outer scopes
// to detect potential ambiguities. // to detect potential ambiguities.
let mut innermost_result: Option<(&NameBinding, Flags, /* conflicts with */ Flags)> = None; let mut innermost_result: Option<(&NameBinding, Flags)> = None;
// Go through all the scopes and try to resolve the name. // Go through all the scopes and try to resolve the name.
let mut where_to_resolve = WhereToResolve::DeriveHelpers; let mut where_to_resolve = WhereToResolve::DeriveHelpers;
@ -638,7 +640,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
(Def::NonMacroAttr(NonMacroAttrKind::DeriveHelper), (Def::NonMacroAttr(NonMacroAttrKind::DeriveHelper),
ty::Visibility::Public, derive.span, Mark::root()) ty::Visibility::Public, derive.span, Mark::root())
.to_name_binding(self.arenas); .to_name_binding(self.arenas);
result = Ok((binding, Flags::DERIVE_HELPERS, Flags::all())); result = Ok((binding, Flags::empty()));
break; break;
} }
} }
@ -648,7 +650,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
} }
WhereToResolve::MacroRules(legacy_scope) => match legacy_scope { WhereToResolve::MacroRules(legacy_scope) => match legacy_scope {
LegacyScope::Binding(legacy_binding) if ident == legacy_binding.ident => LegacyScope::Binding(legacy_binding) if ident == legacy_binding.ident =>
Ok((legacy_binding.binding, Flags::MACRO_RULES, Flags::empty())), Ok((legacy_binding.binding, Flags::MACRO_RULES)),
_ => Err(Determinacy::Determined), _ => Err(Determinacy::Determined),
} }
WhereToResolve::Module(module) => { WhereToResolve::Module(module) => {
@ -662,29 +664,34 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
path_span, path_span,
); );
self.current_module = orig_current_module; self.current_module = orig_current_module;
binding.map(|binding| (binding, Flags::MODULE, Flags::empty())) let misc_flags = if module.is_normal() {
Flags::MISC_SUGGEST_SELF
} else {
Flags::empty()
};
binding.map(|binding| (binding, Flags::MODULE | misc_flags))
} }
WhereToResolve::MacroUsePrelude => { WhereToResolve::MacroUsePrelude => {
let mut result = Err(Determinacy::Determined); let mut result = Err(Determinacy::Determined);
if use_prelude || self.session.rust_2015() { if use_prelude || self.session.rust_2015() {
if let Some(binding) = self.macro_use_prelude.get(&ident.name).cloned() { if let Some(binding) = self.macro_use_prelude.get(&ident.name).cloned() {
result = Ok((binding, Flags::PRELUDE, Flags::empty())); result = Ok((binding, Flags::PRELUDE | Flags::MISC_FROM_PRELUDE));
} }
} }
result result
} }
WhereToResolve::BuiltinMacros => { WhereToResolve::BuiltinMacros => {
match self.builtin_macros.get(&ident.name).cloned() { match self.builtin_macros.get(&ident.name).cloned() {
Some(binding) => Ok((binding, Flags::PRELUDE, Flags::empty())), Some(binding) => Ok((binding, Flags::PRELUDE)),
None => Err(Determinacy::Determined), None => Err(Determinacy::Determined),
} }
} }
WhereToResolve::BuiltinAttrs => { WhereToResolve::BuiltinAttrs => {
if is_builtin_attr_name(ident.name) { if is_builtin_attr_name(ident.name) {
let binding = (Def::NonMacroAttr(NonMacroAttrKind::Builtin), let binding = (Def::NonMacroAttr(NonMacroAttrKind::Builtin),
ty::Visibility::Public, ident.span, Mark::root()) ty::Visibility::Public, DUMMY_SP, Mark::root())
.to_name_binding(self.arenas); .to_name_binding(self.arenas);
Ok((binding, Flags::PRELUDE, Flags::all())) Ok((binding, Flags::PRELUDE))
} else { } else {
Err(Determinacy::Determined) Err(Determinacy::Determined)
} }
@ -694,9 +701,9 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
self.session.plugin_attributes.borrow().iter() self.session.plugin_attributes.borrow().iter()
.any(|(name, _)| ident.name == &**name) { .any(|(name, _)| ident.name == &**name) {
let binding = (Def::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper), let binding = (Def::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper),
ty::Visibility::Public, ident.span, Mark::root()) ty::Visibility::Public, DUMMY_SP, Mark::root())
.to_name_binding(self.arenas); .to_name_binding(self.arenas);
Ok((binding, Flags::PRELUDE, Flags::PRELUDE)) Ok((binding, Flags::PRELUDE))
} else { } else {
Err(Determinacy::Determined) Err(Determinacy::Determined)
} }
@ -706,7 +713,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
if use_prelude { if use_prelude {
if let Some(binding) = self.extern_prelude_get(ident, !record_used, if let Some(binding) = self.extern_prelude_get(ident, !record_used,
innermost_result.is_some()) { innermost_result.is_some()) {
result = Ok((binding, Flags::PRELUDE, Flags::empty())); result = Ok((binding, Flags::PRELUDE));
} }
} }
result result
@ -714,8 +721,8 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
WhereToResolve::ToolPrelude => { WhereToResolve::ToolPrelude => {
if use_prelude && is_known_tool(ident.name) { if use_prelude && is_known_tool(ident.name) {
let binding = (Def::ToolMod, ty::Visibility::Public, let binding = (Def::ToolMod, ty::Visibility::Public,
ident.span, Mark::root()).to_name_binding(self.arenas); DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
Ok((binding, Flags::PRELUDE, Flags::empty())) Ok((binding, Flags::PRELUDE))
} else { } else {
Err(Determinacy::Determined) Err(Determinacy::Determined)
} }
@ -732,7 +739,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
false, false,
path_span, path_span,
) { ) {
result = Ok((binding, Flags::PRELUDE, Flags::empty())); result = Ok((binding, Flags::PRELUDE | Flags::MISC_FROM_PRELUDE));
} }
} }
} }
@ -742,8 +749,8 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
match self.primitive_type_table.primitive_types.get(&ident.name).cloned() { match self.primitive_type_table.primitive_types.get(&ident.name).cloned() {
Some(prim_ty) => { Some(prim_ty) => {
let binding = (Def::PrimTy(prim_ty), ty::Visibility::Public, let binding = (Def::PrimTy(prim_ty), ty::Visibility::Public,
ident.span, Mark::root()).to_name_binding(self.arenas); DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
Ok((binding, Flags::PRELUDE, Flags::empty())) Ok((binding, Flags::PRELUDE))
} }
None => Err(Determinacy::Determined) None => Err(Determinacy::Determined)
} }
@ -793,7 +800,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
}} }}
match result { match result {
Ok((binding, flags, ambig_flags)) => { Ok((binding, flags)) => {
if sub_namespace_mismatch(macro_kind, binding.macro_kind()) { if sub_namespace_mismatch(macro_kind, binding.macro_kind()) {
continue_search!(); continue_search!();
} }
@ -802,28 +809,61 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
return Ok(binding); return Ok(binding);
} }
if let Some((innermost_binding, innermost_flags, innermost_ambig_flags)) if let Some((innermost_binding, innermost_flags)) = innermost_result {
= innermost_result {
// Found another solution, if the first one was "weak", report an error. // Found another solution, if the first one was "weak", report an error.
if binding.def() != innermost_binding.def() && let (def, innermost_def) = (binding.def(), innermost_binding.def());
(is_import || if def != innermost_def {
innermost_binding.is_glob_import() || let builtin = Def::NonMacroAttr(NonMacroAttrKind::Builtin);
innermost_binding.may_appear_after(parent_scope.expansion, binding) || let derive_helper = Def::NonMacroAttr(NonMacroAttrKind::DeriveHelper);
innermost_flags.intersects(ambig_flags) || let legacy_helper =
flags.intersects(innermost_ambig_flags) || Def::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper);
(innermost_flags.contains(Flags::MACRO_RULES) &&
flags.contains(Flags::MODULE) && let ambiguity_error_kind = if is_import {
!self.disambiguate_legacy_vs_modern(innermost_binding, binding))) { Some(AmbiguityKind::Import)
self.ambiguity_errors.push(AmbiguityError { } else if innermost_def == builtin || def == builtin {
ident, Some(AmbiguityKind::BuiltinAttr)
b1: innermost_binding, } else if innermost_def == derive_helper || def == derive_helper {
b2: binding, Some(AmbiguityKind::DeriveHelper)
}); } else if innermost_def == legacy_helper &&
return Ok(innermost_binding); flags.contains(Flags::PRELUDE) ||
def == legacy_helper &&
innermost_flags.contains(Flags::PRELUDE) {
Some(AmbiguityKind::LegacyHelperVsPrelude)
} else if innermost_flags.contains(Flags::MACRO_RULES) &&
flags.contains(Flags::MODULE) &&
!self.disambiguate_legacy_vs_modern(innermost_binding,
binding) {
Some(AmbiguityKind::LegacyVsModern)
} else if innermost_binding.is_glob_import() {
Some(AmbiguityKind::GlobVsOuter)
} else if innermost_binding.may_appear_after(parent_scope.expansion,
binding) {
Some(AmbiguityKind::MoreExpandedVsOuter)
} else {
None
};
if let Some(kind) = ambiguity_error_kind {
let misc = |f: Flags| if f.contains(Flags::MISC_SUGGEST_SELF) {
AmbiguityErrorMisc::SuggestSelf
} else if f.contains(Flags::MISC_FROM_PRELUDE) {
AmbiguityErrorMisc::FromPrelude
} else {
AmbiguityErrorMisc::None
};
self.ambiguity_errors.push(AmbiguityError {
kind,
ident,
b1: innermost_binding,
b2: binding,
misc1: misc(innermost_flags),
misc2: misc(flags),
});
return Ok(innermost_binding);
}
} }
} else { } else {
// Found the first solution. // Found the first solution.
innermost_result = Some((binding, flags, ambig_flags)); innermost_result = Some((binding, flags));
} }
continue_search!(); continue_search!();

79
src/librustc_resolve/resolve_imports.rs
View file

@ -10,7 +10,8 @@
use self::ImportDirectiveSubclass::*; use self::ImportDirectiveSubclass::*;
use {AmbiguityError, CrateLint, Module, ModuleOrUniformRoot, PerNS}; use {AmbiguityError, AmbiguityKind, AmbiguityErrorMisc};
use {CrateLint, Module, ModuleOrUniformRoot, PerNS};
use Namespace::{self, TypeNS, MacroNS}; use Namespace::{self, TypeNS, MacroNS};
use {NameBinding, NameBindingKind, ToNameBinding, PathResult, PrivacyError}; use {NameBinding, NameBindingKind, ToNameBinding, PathResult, PrivacyError};
use {Resolver, Segment}; use {Resolver, Segment};
@ -219,7 +220,7 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
}; };
self.populate_module_if_necessary(crate_root); self.populate_module_if_necessary(crate_root);
let binding = (crate_root, ty::Visibility::Public, let binding = (crate_root, ty::Visibility::Public,
ident.span, Mark::root()).to_name_binding(self.arenas); crate_root.span, Mark::root()).to_name_binding(self.arenas);
return Ok(binding); return Ok(binding);
} }
}; };
@ -244,12 +245,14 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
// Forbid expanded shadowing to avoid time travel. // Forbid expanded shadowing to avoid time travel.
if restricted_shadowing && if restricted_shadowing &&
binding.expansion != Mark::root() && binding.expansion != Mark::root() &&
ns != MacroNS && // In MacroNS, `try_define` always forbids this shadowing
binding.def() != shadowed_glob.def() { binding.def() != shadowed_glob.def() {
self.ambiguity_errors.push(AmbiguityError { self.ambiguity_errors.push(AmbiguityError {
kind: AmbiguityKind::GlobVsExpanded,
ident, ident,
b1: binding, b1: binding,
b2: shadowed_glob, b2: shadowed_glob,
misc1: AmbiguityErrorMisc::None,
misc2: AmbiguityErrorMisc::None,
}); });
} }
} }
@ -471,38 +474,48 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
self.set_binding_parent_module(binding, module); self.set_binding_parent_module(binding, module);
self.update_resolution(module, ident, ns, |this, resolution| { self.update_resolution(module, ident, ns, |this, resolution| {
if let Some(old_binding) = resolution.binding { if let Some(old_binding) = resolution.binding {
if binding.is_glob_import() { match (old_binding.is_glob_import(), binding.is_glob_import()) {
if !old_binding.is_glob_import() && (true, true) => {
!(ns == MacroNS && old_binding.expansion != Mark::root()) { if binding.def() != old_binding.def() {
resolution.shadowed_glob = Some(binding); resolution.binding = Some(this.ambiguity(AmbiguityKind::GlobVsGlob,
} else if binding.def() != old_binding.def() { old_binding, binding));
resolution.binding = Some(this.ambiguity(old_binding, binding)); } else if !old_binding.vis.is_at_least(binding.vis, &*this) {
} else if !old_binding.vis.is_at_least(binding.vis, &*this) { // We are glob-importing the same item but with greater visibility.
// We are glob-importing the same item but with greater visibility. resolution.binding = Some(binding);
resolution.binding = Some(binding); }
} }
} else if old_binding.is_glob_import() { (old_glob @ true, false) | (old_glob @ false, true) => {
if ns == MacroNS && binding.expansion != Mark::root() && let (glob_binding, nonglob_binding) = if old_glob {
binding.def() != old_binding.def() { (old_binding, binding)
resolution.binding = Some(this.ambiguity(binding, old_binding)); } else {
} else { (binding, old_binding)
resolution.binding = Some(binding); };
resolution.shadowed_glob = Some(old_binding); if glob_binding.def() != nonglob_binding.def() &&
ns == MacroNS && nonglob_binding.expansion != Mark::root() {
resolution.binding = Some(this.ambiguity(AmbiguityKind::GlobVsExpanded,
nonglob_binding, glob_binding));
} else {
resolution.binding = Some(nonglob_binding);
resolution.shadowed_glob = Some(glob_binding);
}
} }
} else if let (&NameBindingKind::Def(_, true), &NameBindingKind::Def(_, true)) = (false, false) => {
(&old_binding.kind, &binding.kind) { if let (&NameBindingKind::Def(_, true), &NameBindingKind::Def(_, true)) =
(&old_binding.kind, &binding.kind) {
this.session.buffer_lint_with_diagnostic( this.session.buffer_lint_with_diagnostic(
DUPLICATE_MACRO_EXPORTS, DUPLICATE_MACRO_EXPORTS,
CRATE_NODE_ID, CRATE_NODE_ID,
binding.span, binding.span,
&format!("a macro named `{}` has already been exported", ident), &format!("a macro named `{}` has already been exported", ident),
BuiltinLintDiagnostics::DuplicatedMacroExports( BuiltinLintDiagnostics::DuplicatedMacroExports(
ident, old_binding.span, binding.span)); ident, old_binding.span, binding.span));
resolution.binding = Some(binding); resolution.binding = Some(binding);
} else { } else {
return Err(old_binding); return Err(old_binding);
}
}
} }
} else { } else {
resolution.binding = Some(binding); resolution.binding = Some(binding);
@ -512,10 +525,10 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
}) })
} }
pub fn ambiguity(&self, b1: &'a NameBinding<'a>, b2: &'a NameBinding<'a>) fn ambiguity(&self, kind: AmbiguityKind, b1: &'a NameBinding<'a>, b2: &'a NameBinding<'a>)
-> &'a NameBinding<'a> { -> &'a NameBinding<'a> {
self.arenas.alloc_name_binding(NameBinding { self.arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Ambiguity { b1, b2 }, kind: NameBindingKind::Ambiguity { kind, b1, b2 },
vis: if b1.vis.is_at_least(b2.vis, self) { b1.vis } else { b2.vis }, vis: if b1.vis.is_at_least(b2.vis, self) { b1.vis } else { b2.vis },
span: b1.span, span: b1.span,
expansion: Mark::root(), expansion: Mark::root(),

7
src/test/ui-fulldeps/custom-derive/helper-attr-blocked-by-import-ambig.stderr
View file

@ -1,19 +1,20 @@
error[E0659]: `helper` is ambiguous error[E0659]: `helper` is ambiguous (derive helper attribute vs any other name)
--> $DIR/helper-attr-blocked-by-import-ambig.rs:10:3 --> $DIR/helper-attr-blocked-by-import-ambig.rs:10:3
| |
LL | #[helper] //~ ERROR `helper` is ambiguous LL | #[helper] //~ ERROR `helper` is ambiguous
| ^^^^^^ ambiguous name | ^^^^^^ ambiguous name
| |
note: `helper` could refer to the name defined here note: `helper` could refer to the derive helper attribute defined here
--> $DIR/helper-attr-blocked-by-import-ambig.rs:9:10 --> $DIR/helper-attr-blocked-by-import-ambig.rs:9:10
| |
LL | #[derive(WithHelper)] LL | #[derive(WithHelper)]
| ^^^^^^^^^^ | ^^^^^^^^^^
note: `helper` could also refer to the name imported here note: `helper` could also refer to the attribute macro imported here
--> $DIR/helper-attr-blocked-by-import-ambig.rs:7:5 --> $DIR/helper-attr-blocked-by-import-ambig.rs:7:5
| |
LL | use plugin::helper; LL | use plugin::helper;
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
= help: use `self::helper` to refer to the attribute macro unambiguously
error: aborting due to previous error error: aborting due to previous error

60
src/test/ui-fulldeps/proc-macro/ambiguous-builtin-attrs.stderr
View file

@ -4,95 +4,75 @@ error[E0425]: cannot find value `NonExistent` in this scope
LL | NonExistent; //~ ERROR cannot find value `NonExistent` in this scope LL | NonExistent; //~ ERROR cannot find value `NonExistent` in this scope
| ^^^^^^^^^^^ not found in this scope | ^^^^^^^^^^^ not found in this scope
error[E0659]: `repr` is ambiguous error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
--> $DIR/ambiguous-builtin-attrs.rs:9:3 --> $DIR/ambiguous-builtin-attrs.rs:9:3
| |
LL | #[repr(C)] //~ ERROR `repr` is ambiguous LL | #[repr(C)] //~ ERROR `repr` is ambiguous
| ^^^^ ambiguous name | ^^^^ ambiguous name
| |
note: `repr` could refer to the name imported here = note: `repr` could refer to a built-in attribute
note: `repr` could also refer to the attribute macro imported here
--> $DIR/ambiguous-builtin-attrs.rs:7:5 --> $DIR/ambiguous-builtin-attrs.rs:7:5
| |
LL | use builtin_attrs::*; LL | use builtin_attrs::*;
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
note: `repr` could also refer to the name defined here = help: use `self::repr` to refer to the attribute macro unambiguously
--> $DIR/ambiguous-builtin-attrs.rs:9:3
|
LL | #[repr(C)] //~ ERROR `repr` is ambiguous
| ^^^^
= note: consider adding an explicit import of `repr` to disambiguate
error[E0659]: `repr` is ambiguous error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
--> $DIR/ambiguous-builtin-attrs.rs:11:19 --> $DIR/ambiguous-builtin-attrs.rs:11:19
| |
LL | #[cfg_attr(all(), repr(C))] //~ ERROR `repr` is ambiguous LL | #[cfg_attr(all(), repr(C))] //~ ERROR `repr` is ambiguous
| ^^^^ ambiguous name | ^^^^ ambiguous name
| |
note: `repr` could refer to the name imported here = note: `repr` could refer to a built-in attribute
note: `repr` could also refer to the attribute macro imported here
--> $DIR/ambiguous-builtin-attrs.rs:7:5 --> $DIR/ambiguous-builtin-attrs.rs:7:5
| |
LL | use builtin_attrs::*; LL | use builtin_attrs::*;
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
note: `repr` could also refer to the name defined here = help: use `self::repr` to refer to the attribute macro unambiguously
--> $DIR/ambiguous-builtin-attrs.rs:11:19
|
LL | #[cfg_attr(all(), repr(C))] //~ ERROR `repr` is ambiguous
| ^^^^
= note: consider adding an explicit import of `repr` to disambiguate
error[E0659]: `repr` is ambiguous error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
--> $DIR/ambiguous-builtin-attrs.rs:20:34 --> $DIR/ambiguous-builtin-attrs.rs:20:34
| |
LL | fn non_macro_expanded_location<#[repr(C)] T>() { //~ ERROR `repr` is ambiguous LL | fn non_macro_expanded_location<#[repr(C)] T>() { //~ ERROR `repr` is ambiguous
| ^^^^ ambiguous name | ^^^^ ambiguous name
| |
note: `repr` could refer to the name imported here = note: `repr` could refer to a built-in attribute
note: `repr` could also refer to the attribute macro imported here
--> $DIR/ambiguous-builtin-attrs.rs:7:5 --> $DIR/ambiguous-builtin-attrs.rs:7:5
| |
LL | use builtin_attrs::*; LL | use builtin_attrs::*;
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
note: `repr` could also refer to the name defined here = help: use `self::repr` to refer to the attribute macro unambiguously
--> $DIR/ambiguous-builtin-attrs.rs:20:34
|
LL | fn non_macro_expanded_location<#[repr(C)] T>() { //~ ERROR `repr` is ambiguous
| ^^^^
= note: consider adding an explicit import of `repr` to disambiguate
error[E0659]: `repr` is ambiguous error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
--> $DIR/ambiguous-builtin-attrs.rs:22:11 --> $DIR/ambiguous-builtin-attrs.rs:22:11
| |
LL | #[repr(C)] //~ ERROR `repr` is ambiguous LL | #[repr(C)] //~ ERROR `repr` is ambiguous
| ^^^^ ambiguous name | ^^^^ ambiguous name
| |
note: `repr` could refer to the name imported here = note: `repr` could refer to a built-in attribute
note: `repr` could also refer to the attribute macro imported here
--> $DIR/ambiguous-builtin-attrs.rs:7:5 --> $DIR/ambiguous-builtin-attrs.rs:7:5
| |
LL | use builtin_attrs::*; LL | use builtin_attrs::*;
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
note: `repr` could also refer to the name defined here = help: use `self::repr` to refer to the attribute macro unambiguously
--> $DIR/ambiguous-builtin-attrs.rs:22:11
|
LL | #[repr(C)] //~ ERROR `repr` is ambiguous
| ^^^^
= note: consider adding an explicit import of `repr` to disambiguate
error[E0659]: `feature` is ambiguous error[E0659]: `feature` is ambiguous (built-in attribute vs any other name)
--> $DIR/ambiguous-builtin-attrs.rs:3:4 --> $DIR/ambiguous-builtin-attrs.rs:3:4
| |
LL | #![feature(decl_macro)] //~ ERROR `feature` is ambiguous LL | #![feature(decl_macro)] //~ ERROR `feature` is ambiguous
| ^^^^^^^ ambiguous name | ^^^^^^^ ambiguous name
| |
note: `feature` could refer to the name imported here = note: `feature` could refer to a built-in attribute
note: `feature` could also refer to the attribute macro imported here
--> $DIR/ambiguous-builtin-attrs.rs:7:5 --> $DIR/ambiguous-builtin-attrs.rs:7:5
| |
LL | use builtin_attrs::*; LL | use builtin_attrs::*;
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
note: `feature` could also refer to the name defined here = help: use `self::feature` to refer to the attribute macro unambiguously
--> $DIR/ambiguous-builtin-attrs.rs:3:4
|
LL | #![feature(decl_macro)] //~ ERROR `feature` is ambiguous
| ^^^^^^^
= note: consider adding an explicit import of `feature` to disambiguate
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

7
src/test/ui-fulldeps/proc-macro/derive-helper-shadowing.stderr
View file

@ -1,19 +1,20 @@
error[E0659]: `my_attr` is ambiguous error[E0659]: `my_attr` is ambiguous (derive helper attribute vs any other name)
--> $DIR/derive-helper-shadowing.rs:6:3 --> $DIR/derive-helper-shadowing.rs:6:3
| |
LL | #[my_attr] //~ ERROR `my_attr` is ambiguous LL | #[my_attr] //~ ERROR `my_attr` is ambiguous
| ^^^^^^^ ambiguous name | ^^^^^^^ ambiguous name
| |
note: `my_attr` could refer to the name defined here note: `my_attr` could refer to the derive helper attribute defined here
--> $DIR/derive-helper-shadowing.rs:7:10 --> $DIR/derive-helper-shadowing.rs:7:10
| |
LL | #[derive(MyTrait)] LL | #[derive(MyTrait)]
| ^^^^^^^ | ^^^^^^^
note: `my_attr` could also refer to the name imported here note: `my_attr` could also refer to the attribute macro imported here
--> $DIR/derive-helper-shadowing.rs:4:5 --> $DIR/derive-helper-shadowing.rs:4:5
| |
LL | use derive_helper_shadowing::*; LL | use derive_helper_shadowing::*;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
= help: use `self::my_attr` to refer to the attribute macro unambiguously
error: aborting due to previous error error: aborting due to previous error

9
src/test/ui/error-codes/E0659.stderr
View file

@ -1,20 +1,21 @@
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/E0659.rs:25:15 --> $DIR/E0659.rs:25:15
| |
LL | collider::foo(); //~ ERROR E0659 LL | collider::foo(); //~ ERROR E0659
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name imported here note: `foo` could refer to the function imported here
--> $DIR/E0659.rs:20:13 --> $DIR/E0659.rs:20:13
| |
LL | pub use moon::*; LL | pub use moon::*;
| ^^^^^^^ | ^^^^^^^
note: `foo` could also refer to the name imported here = help: consider adding an explicit import of `foo` to disambiguate
note: `foo` could also refer to the function imported here
--> $DIR/E0659.rs:21:13 --> $DIR/E0659.rs:21:13
| |
LL | pub use earth::*; LL | pub use earth::*;
| ^^^^^^^^ | ^^^^^^^^
= note: consider adding an explicit import of `foo` to disambiguate = help: consider adding an explicit import of `foo` to disambiguate
error: aborting due to previous error error: aborting due to previous error

36
src/test/ui/imports/duplicate.stderr
View file

@ -12,77 +12,81 @@ help: you can use `as` to change the binding name of the import
LL | use a::foo as other_foo; //~ ERROR the name `foo` is defined multiple times LL | use a::foo as other_foo; //~ ERROR the name `foo` is defined multiple times
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/duplicate.rs:56:15 --> $DIR/duplicate.rs:56:15
| |
LL | use self::foo::bar; //~ ERROR `foo` is ambiguous LL | use self::foo::bar; //~ ERROR `foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name imported here note: `foo` could refer to the module imported here
--> $DIR/duplicate.rs:53:9 --> $DIR/duplicate.rs:53:9
| |
LL | use self::m1::*; LL | use self::m1::*;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
note: `foo` could also refer to the name imported here = help: consider adding an explicit import of `foo` to disambiguate
note: `foo` could also refer to the module imported here
--> $DIR/duplicate.rs:54:9 --> $DIR/duplicate.rs:54:9
| |
LL | use self::m2::*; LL | use self::m2::*;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
= note: consider adding an explicit import of `foo` to disambiguate = help: consider adding an explicit import of `foo` to disambiguate
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/duplicate.rs:45:8 --> $DIR/duplicate.rs:45:8
| |
LL | f::foo(); //~ ERROR `foo` is ambiguous LL | f::foo(); //~ ERROR `foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name imported here note: `foo` could refer to the function imported here
--> $DIR/duplicate.rs:34:13 --> $DIR/duplicate.rs:34:13
| |
LL | pub use a::*; LL | pub use a::*;
| ^^^^ | ^^^^
note: `foo` could also refer to the name imported here = help: consider adding an explicit import of `foo` to disambiguate
note: `foo` could also refer to the function imported here
--> $DIR/duplicate.rs:35:13 --> $DIR/duplicate.rs:35:13
| |
LL | pub use b::*; LL | pub use b::*;
| ^^^^ | ^^^^
= note: consider adding an explicit import of `foo` to disambiguate = help: consider adding an explicit import of `foo` to disambiguate
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/duplicate.rs:46:8 --> $DIR/duplicate.rs:46:8
| |
LL | g::foo(); //~ ERROR `foo` is ambiguous LL | g::foo(); //~ ERROR `foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name imported here note: `foo` could refer to the function imported here
--> $DIR/duplicate.rs:39:13 --> $DIR/duplicate.rs:39:13
| |
LL | pub use a::*; LL | pub use a::*;
| ^^^^ | ^^^^
note: `foo` could also refer to the name imported here = help: consider adding an explicit import of `foo` to disambiguate
note: `foo` could also refer to the unresolved item imported here
--> $DIR/duplicate.rs:40:13 --> $DIR/duplicate.rs:40:13
| |
LL | pub use f::*; LL | pub use f::*;
| ^^^^ | ^^^^
= note: consider adding an explicit import of `foo` to disambiguate = help: consider adding an explicit import of `foo` to disambiguate
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/duplicate.rs:59:9 --> $DIR/duplicate.rs:59:9
| |
LL | foo::bar(); //~ ERROR `foo` is ambiguous LL | foo::bar(); //~ ERROR `foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name imported here note: `foo` could refer to the module imported here
--> $DIR/duplicate.rs:53:9 --> $DIR/duplicate.rs:53:9
| |
LL | use self::m1::*; LL | use self::m1::*;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
note: `foo` could also refer to the name imported here = help: consider adding an explicit import of `foo` to disambiguate
note: `foo` could also refer to the module imported here
--> $DIR/duplicate.rs:54:9 --> $DIR/duplicate.rs:54:9
| |
LL | use self::m2::*; LL | use self::m2::*;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
= note: consider adding an explicit import of `foo` to disambiguate = help: consider adding an explicit import of `foo` to disambiguate
error: aborting due to 5 previous errors error: aborting due to 5 previous errors

7
src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr
View file

@ -1,10 +1,11 @@
error[E0659]: `Vec` is ambiguous error[E0659]: `Vec` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/extern-prelude-extern-crate-restricted-shadowing.rs:15:9 --> $DIR/extern-prelude-extern-crate-restricted-shadowing.rs:15:9
| |
LL | Vec::panic!(); //~ ERROR `Vec` is ambiguous LL | Vec::panic!(); //~ ERROR `Vec` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `Vec` could refer to the name defined here = note: `Vec` could refer to a struct from prelude
note: `Vec` could also refer to the extern crate imported here
--> $DIR/extern-prelude-extern-crate-restricted-shadowing.rs:7:9 --> $DIR/extern-prelude-extern-crate-restricted-shadowing.rs:7:9
| |
LL | extern crate std as Vec; LL | extern crate std as Vec;
@ -12,8 +13,6 @@ LL | extern crate std as Vec;
... ...
LL | define_vec!(); LL | define_vec!();
| -------------- in this macro invocation | -------------- in this macro invocation
note: `Vec` could also refer to the name defined here
= note: macro-expanded items do not shadow when used in a macro invocation path
error: aborting due to previous error error: aborting due to previous error

26
src/test/ui/imports/glob-shadowing.stderr
View file

@ -1,48 +1,50 @@
error[E0659]: `env` is ambiguous error[E0659]: `env` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/glob-shadowing.rs:21:17 --> $DIR/glob-shadowing.rs:21:17
| |
LL | let x = env!("PATH"); //~ ERROR `env` is ambiguous LL | let x = env!("PATH"); //~ ERROR `env` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `env` could refer to the name imported here = note: `env` could refer to a built-in macro
note: `env` could also refer to the macro imported here
--> $DIR/glob-shadowing.rs:19:9 --> $DIR/glob-shadowing.rs:19:9
| |
LL | use m::*; LL | use m::*;
| ^^^^ | ^^^^
= note: `env` is also a builtin macro = help: consider adding an explicit import of `env` to disambiguate
= note: consider adding an explicit import of `env` to disambiguate = help: or use `self::env` to refer to the macro unambiguously
error[E0659]: `env` is ambiguous error[E0659]: `env` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/glob-shadowing.rs:29:21 --> $DIR/glob-shadowing.rs:29:21
| |
LL | let x = env!("PATH"); //~ ERROR `env` is ambiguous LL | let x = env!("PATH"); //~ ERROR `env` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `env` could refer to the name imported here = note: `env` could refer to a built-in macro
note: `env` could also refer to the macro imported here
--> $DIR/glob-shadowing.rs:27:13 --> $DIR/glob-shadowing.rs:27:13
| |
LL | use m::*; LL | use m::*;
| ^^^^ | ^^^^
= note: `env` is also a builtin macro = help: consider adding an explicit import of `env` to disambiguate
= note: consider adding an explicit import of `env` to disambiguate
error[E0659]: `fenv` is ambiguous error[E0659]: `fenv` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/glob-shadowing.rs:39:21 --> $DIR/glob-shadowing.rs:39:21
| |
LL | let x = fenv!(); //~ ERROR `fenv` is ambiguous LL | let x = fenv!(); //~ ERROR `fenv` is ambiguous
| ^^^^ ambiguous name | ^^^^ ambiguous name
| |
note: `fenv` could refer to the name imported here note: `fenv` could refer to the macro imported here
--> $DIR/glob-shadowing.rs:37:13 --> $DIR/glob-shadowing.rs:37:13
| |
LL | use m::*; LL | use m::*;
| ^^^^ | ^^^^
note: `fenv` could also refer to the name defined here = help: consider adding an explicit import of `fenv` to disambiguate
note: `fenv` could also refer to the macro defined here
--> $DIR/glob-shadowing.rs:35:5 --> $DIR/glob-shadowing.rs:35:5
| |
LL | pub macro fenv($e: expr) { $e } LL | pub macro fenv($e: expr) { $e }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: consider adding an explicit import of `fenv` to disambiguate = help: use `self::fenv` to refer to the macro unambiguously
error: aborting due to 3 previous errors error: aborting due to 3 previous errors

7
src/test/ui/imports/issue-53269.stderr
View file

@ -4,22 +4,23 @@ error[E0432]: unresolved import `nonexistent_module`
LL | use nonexistent_module::mac; //~ ERROR unresolved import `nonexistent_module` LL | use nonexistent_module::mac; //~ ERROR unresolved import `nonexistent_module`
| ^^^^^^^^^^^^^^^^^^ Maybe a missing `extern crate nonexistent_module;`? | ^^^^^^^^^^^^^^^^^^ Maybe a missing `extern crate nonexistent_module;`?
error[E0659]: `mac` is ambiguous error[E0659]: `mac` is ambiguous (`macro_rules` vs non-`macro_rules` from other module)
--> $DIR/issue-53269.rs:18:5 --> $DIR/issue-53269.rs:18:5
| |
LL | mac!(); //~ ERROR `mac` is ambiguous LL | mac!(); //~ ERROR `mac` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `mac` could refer to the name defined here note: `mac` could refer to the macro defined here
--> $DIR/issue-53269.rs:13:1 --> $DIR/issue-53269.rs:13:1
| |
LL | macro_rules! mac { () => () } LL | macro_rules! mac { () => () }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `mac` could also refer to the name imported here note: `mac` could also refer to the unresolved item imported here
--> $DIR/issue-53269.rs:16:9 --> $DIR/issue-53269.rs:16:9
| |
LL | use nonexistent_module::mac; //~ ERROR unresolved import `nonexistent_module` LL | use nonexistent_module::mac; //~ ERROR unresolved import `nonexistent_module`
| ^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^
= help: use `self::mac` to refer to the unresolved item unambiguously
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

32
src/test/ui/imports/local-modularized-tricky-fail-1.stderr
View file

@ -1,10 +1,10 @@
error[E0659]: `exported` is ambiguous error[E0659]: `exported` is ambiguous (glob import vs macro-expanded name in the same module during import/macro resolution)
--> $DIR/local-modularized-tricky-fail-1.rs:38:1 --> $DIR/local-modularized-tricky-fail-1.rs:38:1
| |
LL | exported!(); //~ ERROR `exported` is ambiguous LL | exported!(); //~ ERROR `exported` is ambiguous
| ^^^^^^^^ ambiguous name | ^^^^^^^^ ambiguous name
| |
note: `exported` could refer to the name defined here note: `exported` could refer to the macro defined here
--> $DIR/local-modularized-tricky-fail-1.rs:15:5 --> $DIR/local-modularized-tricky-fail-1.rs:15:5
| |
LL | / macro_rules! exported { LL | / macro_rules! exported {
@ -14,20 +14,21 @@ LL | | }
... ...
LL | define_exported!(); LL | define_exported!();
| ------------------- in this macro invocation | ------------------- in this macro invocation
note: `exported` could also refer to the name imported here note: `exported` could also refer to the macro imported here
--> $DIR/local-modularized-tricky-fail-1.rs:32:5 --> $DIR/local-modularized-tricky-fail-1.rs:32:5
| |
LL | use inner1::*; LL | use inner1::*;
| ^^^^^^^^^ | ^^^^^^^^^
= note: macro-expanded macros do not shadow = help: consider adding an explicit import of `exported` to disambiguate
error[E0659]: `include` is ambiguous error[E0659]: `include` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/local-modularized-tricky-fail-1.rs:56:1 --> $DIR/local-modularized-tricky-fail-1.rs:56:1
| |
LL | include!(); //~ ERROR `include` is ambiguous LL | include!(); //~ ERROR `include` is ambiguous
| ^^^^^^^ ambiguous name | ^^^^^^^ ambiguous name
| |
note: `include` could refer to the name defined here = note: `include` could refer to a built-in macro
note: `include` could also refer to the macro defined here
--> $DIR/local-modularized-tricky-fail-1.rs:27:5 --> $DIR/local-modularized-tricky-fail-1.rs:27:5
| |
LL | / macro_rules! include { LL | / macro_rules! include {
@ -37,16 +38,16 @@ LL | | }
... ...
LL | define_include!(); LL | define_include!();
| ------------------ in this macro invocation | ------------------ in this macro invocation
= note: `include` is also a builtin macro = help: use `self::include` to refer to the macro unambiguously
= note: macro-expanded macros do not shadow
error[E0659]: `panic` is ambiguous error[E0659]: `panic` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/local-modularized-tricky-fail-1.rs:45:5 --> $DIR/local-modularized-tricky-fail-1.rs:45:5
| |
LL | panic!(); //~ ERROR `panic` is ambiguous LL | panic!(); //~ ERROR `panic` is ambiguous
| ^^^^^ ambiguous name | ^^^^^ ambiguous name
| |
note: `panic` could refer to the name defined here = note: `panic` could refer to a macro from prelude
note: `panic` could also refer to the macro defined here
--> $DIR/local-modularized-tricky-fail-1.rs:21:5 --> $DIR/local-modularized-tricky-fail-1.rs:21:5
| |
LL | / macro_rules! panic { LL | / macro_rules! panic {
@ -56,16 +57,16 @@ LL | | }
... ...
LL | define_panic!(); LL | define_panic!();
| ---------------- in this macro invocation | ---------------- in this macro invocation
= note: `panic` is also a builtin macro = help: use `self::panic` to refer to the macro unambiguously
= note: macro-expanded macros do not shadow
error[E0659]: `panic` is ambiguous error[E0659]: `panic` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> <::std::macros::panic macros>:1:13 --> <::std::macros::panic macros>:1:13
| |
LL | ( ) => ( { panic ! ( "explicit panic" ) } ) ; ( $ msg : expr ) => ( LL | ( ) => ( { panic ! ( "explicit panic" ) } ) ; ( $ msg : expr ) => (
| ^^^^^ ambiguous name | ^^^^^ ambiguous name
| |
note: `panic` could refer to the name defined here = note: `panic` could refer to a macro from prelude
note: `panic` could also refer to the macro defined here
--> $DIR/local-modularized-tricky-fail-1.rs:21:5 --> $DIR/local-modularized-tricky-fail-1.rs:21:5
| |
LL | / macro_rules! panic { LL | / macro_rules! panic {
@ -75,8 +76,7 @@ LL | | }
... ...
LL | define_panic!(); LL | define_panic!();
| ---------------- in this macro invocation | ---------------- in this macro invocation
= note: `panic` is also a builtin macro = help: use `self::panic` to refer to the macro unambiguously
= note: macro-expanded macros do not shadow
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

16
src/test/ui/imports/macro-paths.stderr
View file

@ -1,40 +1,40 @@
error[E0659]: `bar` is ambiguous error[E0659]: `bar` is ambiguous (glob import vs macro-expanded name in the same module during import/macro resolution)
--> $DIR/macro-paths.rs:23:5 --> $DIR/macro-paths.rs:23:5
| |
LL | bar::m! { //~ ERROR ambiguous LL | bar::m! { //~ ERROR ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `bar` could refer to the name defined here note: `bar` could refer to the module defined here
--> $DIR/macro-paths.rs:24:9 --> $DIR/macro-paths.rs:24:9
| |
LL | mod bar { pub use two_macros::m; } LL | mod bar { pub use two_macros::m; }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `bar` could also refer to the name imported here note: `bar` could also refer to the module imported here
--> $DIR/macro-paths.rs:22:9 --> $DIR/macro-paths.rs:22:9
| |
LL | use foo::*; LL | use foo::*;
| ^^^^^^ | ^^^^^^
= note: macro-expanded items do not shadow when used in a macro invocation path = help: consider adding an explicit import of `bar` to disambiguate
error[E0659]: `baz` is ambiguous error[E0659]: `baz` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/macro-paths.rs:33:5 --> $DIR/macro-paths.rs:33:5
| |
LL | baz::m! { //~ ERROR ambiguous LL | baz::m! { //~ ERROR ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `baz` could refer to the name defined here note: `baz` could refer to the module defined here
--> $DIR/macro-paths.rs:34:9 --> $DIR/macro-paths.rs:34:9
| |
LL | mod baz { pub use two_macros::m; } LL | mod baz { pub use two_macros::m; }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `baz` could also refer to the name defined here note: `baz` could also refer to the module defined here
--> $DIR/macro-paths.rs:28:1 --> $DIR/macro-paths.rs:28:1
| |
LL | / pub mod baz { LL | / pub mod baz {
LL | | pub use two_macros::m; LL | | pub use two_macros::m;
LL | | } LL | | }
| |_^ | |_^
= note: macro-expanded items do not shadow when used in a macro invocation path = help: use `self::baz` to refer to the module unambiguously
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

16
src/test/ui/imports/macros.stderr
View file

@ -1,38 +1,38 @@
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (glob import vs macro-expanded name in the same module during import/macro resolution)
--> $DIR/macros.rs:26:5 --> $DIR/macros.rs:26:5
| |
LL | m! { //~ ERROR ambiguous LL | m! { //~ ERROR ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name imported here note: `m` could refer to the macro imported here
--> $DIR/macros.rs:27:13 --> $DIR/macros.rs:27:13
| |
LL | use foo::m; LL | use foo::m;
| ^^^^^^ | ^^^^^^
note: `m` could also refer to the name imported here note: `m` could also refer to the macro imported here
--> $DIR/macros.rs:25:9 --> $DIR/macros.rs:25:9
| |
LL | use two_macros::*; LL | use two_macros::*;
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
= note: macro-expanded macro imports do not shadow = help: consider adding an explicit import of `m` to disambiguate
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/macros.rs:39:9 --> $DIR/macros.rs:39:9
| |
LL | m! { //~ ERROR ambiguous LL | m! { //~ ERROR ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name imported here note: `m` could refer to the macro imported here
--> $DIR/macros.rs:40:17 --> $DIR/macros.rs:40:17
| |
LL | use two_macros::n as m; LL | use two_macros::n as m;
| ^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^
note: `m` could also refer to the name imported here note: `m` could also refer to the macro imported here
--> $DIR/macros.rs:32:9 --> $DIR/macros.rs:32:9
| |
LL | use two_macros::m; LL | use two_macros::m;
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
= note: macro-expanded macro imports do not shadow = help: use `self::m` to refer to the macro unambiguously
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

9
src/test/ui/imports/rfc-1560-warning-cycle.stderr
View file

@ -1,20 +1,21 @@
error[E0659]: `Foo` is ambiguous error[E0659]: `Foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/rfc-1560-warning-cycle.rs:19:17 --> $DIR/rfc-1560-warning-cycle.rs:19:17
| |
LL | fn f(_: Foo) {} //~ ERROR `Foo` is ambiguous LL | fn f(_: Foo) {} //~ ERROR `Foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `Foo` could refer to the name imported here note: `Foo` could refer to the struct imported here
--> $DIR/rfc-1560-warning-cycle.rs:17:13 --> $DIR/rfc-1560-warning-cycle.rs:17:13
| |
LL | use *; LL | use *;
| ^ | ^
note: `Foo` could also refer to the name imported here = help: consider adding an explicit import of `Foo` to disambiguate
note: `Foo` could also refer to the struct imported here
--> $DIR/rfc-1560-warning-cycle.rs:18:13 --> $DIR/rfc-1560-warning-cycle.rs:18:13
| |
LL | use bar::*; LL | use bar::*;
| ^^^^^^ | ^^^^^^
= note: consider adding an explicit import of `Foo` to disambiguate = help: consider adding an explicit import of `Foo` to disambiguate
error: aborting due to previous error error: aborting due to previous error

33
src/test/ui/imports/shadow_builtin_macros.stderr
View file

@ -1,38 +1,40 @@
error[E0659]: `panic` is ambiguous error[E0659]: `panic` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/shadow_builtin_macros.rs:25:14 --> $DIR/shadow_builtin_macros.rs:25:14
| |
LL | fn f() { panic!(); } //~ ERROR ambiguous LL | fn f() { panic!(); } //~ ERROR ambiguous
| ^^^^^ ambiguous name | ^^^^^ ambiguous name
| |
note: `panic` could refer to the name imported here = note: `panic` could refer to a macro from prelude
note: `panic` could also refer to the macro imported here
--> $DIR/shadow_builtin_macros.rs:24:9 --> $DIR/shadow_builtin_macros.rs:24:9
| |
LL | use foo::*; LL | use foo::*;
| ^^^^^^ | ^^^^^^
= note: `panic` is also a builtin macro = help: consider adding an explicit import of `panic` to disambiguate
= note: consider adding an explicit import of `panic` to disambiguate = help: or use `self::panic` to refer to the macro unambiguously
error[E0659]: `panic` is ambiguous error[E0659]: `panic` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/shadow_builtin_macros.rs:30:14 --> $DIR/shadow_builtin_macros.rs:30:14
| |
LL | fn f() { panic!(); } //~ ERROR ambiguous LL | fn f() { panic!(); } //~ ERROR ambiguous
| ^^^^^ ambiguous name | ^^^^^ ambiguous name
| |
note: `panic` could refer to the name imported here = note: `panic` could refer to a macro from prelude
note: `panic` could also refer to the macro imported here
--> $DIR/shadow_builtin_macros.rs:29:26 --> $DIR/shadow_builtin_macros.rs:29:26
| |
LL | ::two_macros::m!(use foo::panic;); LL | ::two_macros::m!(use foo::panic;);
| ^^^^^^^^^^ | ^^^^^^^^^^
= note: `panic` is also a builtin macro = help: use `self::panic` to refer to the macro unambiguously
= note: macro-expanded macro imports do not shadow
error[E0659]: `panic` is ambiguous error[E0659]: `panic` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/shadow_builtin_macros.rs:43:5 --> $DIR/shadow_builtin_macros.rs:43:5
| |
LL | panic!(); //~ ERROR `panic` is ambiguous LL | panic!(); //~ ERROR `panic` is ambiguous
| ^^^^^ ambiguous name | ^^^^^ ambiguous name
| |
note: `panic` could refer to the name defined here = note: `panic` could refer to a macro from prelude
note: `panic` could also refer to the macro defined here
--> $DIR/shadow_builtin_macros.rs:40:9 --> $DIR/shadow_builtin_macros.rs:40:9
| |
LL | macro_rules! panic { () => {} } LL | macro_rules! panic { () => {} }
@ -40,26 +42,25 @@ LL | macro_rules! panic { () => {} }
LL | } } LL | } }
LL | m!(); LL | m!();
| ----- in this macro invocation | ----- in this macro invocation
= note: `panic` is also a builtin macro
= note: macro-expanded macros do not shadow
error[E0659]: `n` is ambiguous error[E0659]: `n` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/shadow_builtin_macros.rs:59:5 --> $DIR/shadow_builtin_macros.rs:59:5
| |
LL | n!(); //~ ERROR ambiguous LL | n!(); //~ ERROR ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `n` could refer to the name imported here note: `n` could refer to the macro imported here
--> $DIR/shadow_builtin_macros.rs:58:9 --> $DIR/shadow_builtin_macros.rs:58:9
| |
LL | use bar::*; LL | use bar::*;
| ^^^^^^ | ^^^^^^
note: `n` could also refer to the name imported here = help: consider adding an explicit import of `n` to disambiguate
= help: or use `self::n` to refer to the macro unambiguously
note: `n` could also refer to the macro imported here
--> $DIR/shadow_builtin_macros.rs:46:13 --> $DIR/shadow_builtin_macros.rs:46:13
| |
LL | #[macro_use(n)] LL | #[macro_use(n)]
| ^ | ^
= note: consider adding an explicit import of `n` to disambiguate
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

12
src/test/ui/macros/ambiguity-legacy-vs-modern.stderr
View file

@ -1,32 +1,32 @@
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (`macro_rules` vs non-`macro_rules` from other module)
--> $DIR/ambiguity-legacy-vs-modern.rs:31:9 --> $DIR/ambiguity-legacy-vs-modern.rs:31:9
| |
LL | m!() //~ ERROR `m` is ambiguous LL | m!() //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/ambiguity-legacy-vs-modern.rs:26:5 --> $DIR/ambiguity-legacy-vs-modern.rs:26:5
| |
LL | macro_rules! m { () => (()) } LL | macro_rules! m { () => (()) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/ambiguity-legacy-vs-modern.rs:29:9 --> $DIR/ambiguity-legacy-vs-modern.rs:29:9
| |
LL | macro m() { 0 } LL | macro m() { 0 }
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (`macro_rules` vs non-`macro_rules` from other module)
--> $DIR/ambiguity-legacy-vs-modern.rs:43:5 --> $DIR/ambiguity-legacy-vs-modern.rs:43:5
| |
LL | m!() //~ ERROR `m` is ambiguous LL | m!() //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/ambiguity-legacy-vs-modern.rs:40:9 --> $DIR/ambiguity-legacy-vs-modern.rs:40:9
| |
LL | macro_rules! m { () => (()) } LL | macro_rules! m { () => (()) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/ambiguity-legacy-vs-modern.rs:36:5 --> $DIR/ambiguity-legacy-vs-modern.rs:36:5
| |
LL | macro m() { 0 } LL | macro m() { 0 }

9
src/test/ui/macros/macro-path-prelude-shadowing.stderr
View file

@ -1,16 +1,17 @@
error[E0659]: `std` is ambiguous error[E0659]: `std` is ambiguous (glob import vs any other name from outer scope during import/macro resolution)
--> $DIR/macro-path-prelude-shadowing.rs:39:9 --> $DIR/macro-path-prelude-shadowing.rs:39:9
| |
LL | std::panic!(); //~ ERROR `std` is ambiguous LL | std::panic!(); //~ ERROR `std` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `std` could refer to the name imported here = note: `std` could refer to a built-in extern crate
note: `std` could also refer to the module imported here
--> $DIR/macro-path-prelude-shadowing.rs:37:9 --> $DIR/macro-path-prelude-shadowing.rs:37:9
| |
LL | use m2::*; // glob-import user-defined `std` LL | use m2::*; // glob-import user-defined `std`
| ^^^^^ | ^^^^^
note: `std` could also refer to the name defined here = help: consider adding an explicit import of `std` to disambiguate
= note: consider adding an explicit import of `std` to disambiguate = help: or use `self::std` to refer to the module unambiguously
error: aborting due to previous error error: aborting due to previous error

7
src/test/ui/macros/macro-shadowing.stderr
View file

@ -9,13 +9,13 @@ LL | m1!();
| |
= note: macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560) = note: macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)
error[E0659]: `foo` is ambiguous error[E0659]: `foo` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/macro-shadowing.rs:27:1 --> $DIR/macro-shadowing.rs:27:1
| |
LL | foo!(); //~ ERROR `foo` is ambiguous LL | foo!(); //~ ERROR `foo` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `foo` could refer to the name defined here note: `foo` could refer to the macro defined here
--> $DIR/macro-shadowing.rs:20:5 --> $DIR/macro-shadowing.rs:20:5
| |
LL | macro_rules! foo { () => {} } LL | macro_rules! foo { () => {} }
@ -23,12 +23,11 @@ LL | macro_rules! foo { () => {} }
... ...
LL | m1!(); LL | m1!();
| ------ in this macro invocation | ------ in this macro invocation
note: `foo` could also refer to the name defined here note: `foo` could also refer to the macro defined here
--> $DIR/macro-shadowing.rs:15:1 --> $DIR/macro-shadowing.rs:15:1
| |
LL | macro_rules! foo { () => {} } LL | macro_rules! foo { () => {} }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: macro-expanded macros do not shadow
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

56
src/test/ui/macros/restricted-shadowing-legacy.stderr
View file

@ -1,10 +1,10 @@
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:101:13 --> $DIR/restricted-shadowing-legacy.rs:101:13
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -12,7 +12,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:97:9 --> $DIR/restricted-shadowing-legacy.rs:97:9
| |
LL | macro_rules! m { () => {} } LL | macro_rules! m { () => {} }
@ -20,15 +20,14 @@ LL | macro_rules! m { () => {} }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:139:42 --> $DIR/restricted-shadowing-legacy.rs:139:42
| |
LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -36,7 +35,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:135:9 --> $DIR/restricted-shadowing-legacy.rs:135:9
| |
LL | macro_rules! m { () => {} } LL | macro_rules! m { () => {} }
@ -44,15 +43,14 @@ LL | macro_rules! m { () => {} }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:148:9 --> $DIR/restricted-shadowing-legacy.rs:148:9
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -60,7 +58,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:144:9 --> $DIR/restricted-shadowing-legacy.rs:144:9
| |
LL | macro_rules! m { () => {} } LL | macro_rules! m { () => {} }
@ -68,15 +66,14 @@ LL | macro_rules! m { () => {} }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:164:9 --> $DIR/restricted-shadowing-legacy.rs:164:9
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -84,7 +81,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:85:9 --> $DIR/restricted-shadowing-legacy.rs:85:9
| |
LL | macro_rules! m { () => { Wrong } } LL | macro_rules! m { () => { Wrong } }
@ -92,15 +89,14 @@ LL | macro_rules! m { () => { Wrong } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:180:13 --> $DIR/restricted-shadowing-legacy.rs:180:13
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -108,7 +104,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:85:9 --> $DIR/restricted-shadowing-legacy.rs:85:9
| |
LL | macro_rules! m { () => { Wrong } } LL | macro_rules! m { () => { Wrong } }
@ -116,15 +112,14 @@ LL | macro_rules! m { () => { Wrong } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:218:42 --> $DIR/restricted-shadowing-legacy.rs:218:42
| |
LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -132,7 +127,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:85:9 --> $DIR/restricted-shadowing-legacy.rs:85:9
| |
LL | macro_rules! m { () => { Wrong } } LL | macro_rules! m { () => { Wrong } }
@ -140,15 +135,14 @@ LL | macro_rules! m { () => { Wrong } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:232:9 --> $DIR/restricted-shadowing-legacy.rs:232:9
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -156,7 +150,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:227:13 --> $DIR/restricted-shadowing-legacy.rs:227:13
| |
LL | macro_rules! m { () => {} } LL | macro_rules! m { () => {} }
@ -164,15 +158,14 @@ LL | macro_rules! m { () => {} }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-legacy.rs:262:42 --> $DIR/restricted-shadowing-legacy.rs:262:42
| |
LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous LL | macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:88:9 --> $DIR/restricted-shadowing-legacy.rs:88:9
| |
LL | macro_rules! m { () => { Right } } LL | macro_rules! m { () => { Right } }
@ -180,7 +173,7 @@ LL | macro_rules! m { () => { Right } }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-legacy.rs:257:13 --> $DIR/restricted-shadowing-legacy.rs:257:13
| |
LL | macro_rules! m { () => {} } LL | macro_rules! m { () => {} }
@ -188,7 +181,6 @@ LL | macro_rules! m { () => {} }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error: aborting due to 8 previous errors error: aborting due to 8 previous errors

42
src/test/ui/macros/restricted-shadowing-modern.stderr
View file

@ -1,10 +1,10 @@
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:106:17 --> $DIR/restricted-shadowing-modern.rs:106:17
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -12,7 +12,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:101:9 --> $DIR/restricted-shadowing-modern.rs:101:9
| |
LL | macro m() {} LL | macro m() {}
@ -20,15 +20,14 @@ LL | macro m() {}
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:149:33 --> $DIR/restricted-shadowing-modern.rs:149:33
| |
LL | macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous LL | macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -36,7 +35,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:145:9 --> $DIR/restricted-shadowing-modern.rs:145:9
| |
LL | macro m() {} LL | macro m() {}
@ -44,15 +43,14 @@ LL | macro m() {}
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:158:13 --> $DIR/restricted-shadowing-modern.rs:158:13
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -60,7 +58,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:155:9 --> $DIR/restricted-shadowing-modern.rs:155:9
| |
LL | macro m() {} LL | macro m() {}
@ -68,15 +66,14 @@ LL | macro m() {}
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:174:13 --> $DIR/restricted-shadowing-modern.rs:174:13
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -84,7 +81,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:87:9 --> $DIR/restricted-shadowing-modern.rs:87:9
| |
LL | macro m() { Wrong } LL | macro m() { Wrong }
@ -92,15 +89,14 @@ LL | macro m() { Wrong }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:192:17 --> $DIR/restricted-shadowing-modern.rs:192:17
| |
LL | m!(); //~ ERROR `m` is ambiguous LL | m!(); //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -108,7 +104,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:87:9 --> $DIR/restricted-shadowing-modern.rs:87:9
| |
LL | macro m() { Wrong } LL | macro m() { Wrong }
@ -116,15 +112,14 @@ LL | macro m() { Wrong }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error[E0659]: `m` is ambiguous error[E0659]: `m` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/restricted-shadowing-modern.rs:235:33 --> $DIR/restricted-shadowing-modern.rs:235:33
| |
LL | macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous LL | macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
| ^ ambiguous name | ^ ambiguous name
| |
note: `m` could refer to the name defined here note: `m` could refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:91:9 --> $DIR/restricted-shadowing-modern.rs:91:9
| |
LL | macro m() { Right } LL | macro m() { Right }
@ -132,7 +127,7 @@ LL | macro m() { Right }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
note: `m` could also refer to the name defined here note: `m` could also refer to the macro defined here
--> $DIR/restricted-shadowing-modern.rs:87:9 --> $DIR/restricted-shadowing-modern.rs:87:9
| |
LL | macro m() { Wrong } LL | macro m() { Wrong }
@ -140,7 +135,6 @@ LL | macro m() { Wrong }
... ...
LL | include!(); LL | include!();
| ----------- in this macro invocation | ----------- in this macro invocation
= note: macro-expanded macros do not shadow
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

7
src/test/ui/out-of-order-shadowing.stderr
View file

@ -1,20 +1,19 @@
error[E0659]: `bar` is ambiguous error[E0659]: `bar` is ambiguous (macro-expanded name vs less macro-expanded name from outer scope during import/macro resolution)
--> $DIR/out-of-order-shadowing.rs:15:1 --> $DIR/out-of-order-shadowing.rs:15:1
| |
LL | bar!(); //~ ERROR `bar` is ambiguous LL | bar!(); //~ ERROR `bar` is ambiguous
| ^^^ ambiguous name | ^^^ ambiguous name
| |
note: `bar` could refer to the name defined here note: `bar` could refer to the macro defined here
--> $DIR/out-of-order-shadowing.rs:14:1 --> $DIR/out-of-order-shadowing.rs:14:1
| |
LL | define_macro!(bar); LL | define_macro!(bar);
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
note: `bar` could also refer to the name defined here note: `bar` could also refer to the macro defined here
--> $DIR/out-of-order-shadowing.rs:13:1 --> $DIR/out-of-order-shadowing.rs:13:1
| |
LL | macro_rules! bar { () => {} } LL | macro_rules! bar { () => {} }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: macro-expanded macros do not shadow
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) = 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 error: aborting due to previous error

2
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs
View file

@ -14,7 +14,7 @@
mod foo { mod foo {
pub use std::io; pub use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
macro_rules! m { macro_rules! m {
() => { () => {

23
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr
View file

@ -1,16 +1,23 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-macros-nested.rs:16:13 --> $DIR/ambiguity-macros-nested.rs:16:13
| |
LL | pub use std::io; LL | pub use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-macros-nested.rs:21:13
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_____________- may refer to `self::std` in the future | |_____________^
| ...
= help: write `::std` or `self::std` explicitly instead LL | m!();
= note: in the future, `#![feature(uniform_paths)]` may become the default | ----- in this macro invocation
= help: use `self::std` to refer to the module unambiguously
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs
View file

@ -13,7 +13,7 @@
// This test is similar to `ambiguity.rs`, but with macros defining local items. // This test is similar to `ambiguity.rs`, but with macros defining local items.
use std::io; use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
macro_rules! m { macro_rules! m {
() => { () => {

23
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr
View file

@ -1,16 +1,23 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-macros.rs:15:5 --> $DIR/ambiguity-macros.rs:15:5
| |
LL | use std::io; LL | use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-macros.rs:20:9
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_________- may refer to `self::std` in the future | |_________^
| ...
= help: write `::std` or `self::std` explicitly instead LL | m!();
= note: in the future, `#![feature(uniform_paths)]` may become the default | ----- in this macro invocation
= help: use `self::std` to refer to the module unambiguously
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs
View file

@ -14,7 +14,7 @@
mod foo { mod foo {
pub use std::io; pub use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
mod std { mod std {
pub struct io; pub struct io;

20
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr
View file

@ -1,16 +1,20 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-nested.rs:16:13 --> $DIR/ambiguity-nested.rs:16:13
| |
LL | pub use std::io; LL | pub use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-nested.rs:19:5
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_____- may refer to `self::std` in the future | |_____^
| = help: use `self::std` to refer to the module unambiguously
= help: write `::std` or `self::std` explicitly instead
= note: in the future, `#![feature(uniform_paths)]` may become the default
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs
View file

@ -11,7 +11,7 @@
// edition:2018 // edition:2018
use std::io; use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
mod std { mod std {
pub struct io; pub struct io;

20
src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr
View file

@ -1,16 +1,20 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity.rs:13:5 --> $DIR/ambiguity.rs:13:5
| |
LL | use std::io; LL | use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity.rs:16:1
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_- may refer to `self::std` in the future | |_^
| = help: use `self::std` to refer to the module unambiguously
= help: write `::std` or `self::std` explicitly instead
= note: in the future, `#![feature(uniform_paths)]` may become the default
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.rs
View file

@ -16,7 +16,7 @@
mod foo { mod foo {
pub use std::io; pub use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
macro_rules! m { macro_rules! m {
() => { () => {

23
src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
View file

@ -1,16 +1,23 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-macros-nested.rs:18:13 --> $DIR/ambiguity-macros-nested.rs:18:13
| |
LL | pub use std::io; LL | pub use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-macros-nested.rs:23:13
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_____________- can refer to `self::std` | |_____________^
| ...
= help: write `::std` or `self::std` explicitly instead LL | m!();
= note: relative `use` paths enabled by `#![feature(uniform_paths)]` | ----- in this macro invocation
= help: use `self::std` to refer to the module unambiguously
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths/ambiguity-macros.rs
View file

@ -15,7 +15,7 @@
// This test is similar to `ambiguity.rs`, but with macros defining local items. // This test is similar to `ambiguity.rs`, but with macros defining local items.
use std::io; use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
macro_rules! m { macro_rules! m {
() => { () => {

23
src/test/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
View file

@ -1,16 +1,23 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-macros.rs:17:5 --> $DIR/ambiguity-macros.rs:17:5
| |
LL | use std::io; LL | use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-macros.rs:22:9
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_________- can refer to `self::std` | |_________^
| ...
= help: write `::std` or `self::std` explicitly instead LL | m!();
= note: relative `use` paths enabled by `#![feature(uniform_paths)]` | ----- in this macro invocation
= help: use `self::std` to refer to the module unambiguously
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths/ambiguity-nested.rs
View file

@ -16,7 +16,7 @@
mod foo { mod foo {
pub use std::io; pub use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
mod std { mod std {
pub struct io; pub struct io;

20
src/test/ui/rust-2018/uniform-paths/ambiguity-nested.stderr
View file

@ -1,16 +1,20 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity-nested.rs:18:13 --> $DIR/ambiguity-nested.rs:18:13
| |
LL | pub use std::io; LL | pub use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity-nested.rs:21:5
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_____- can refer to `self::std` | |_____^
| = help: use `self::std` to refer to the module unambiguously
= help: write `::std` or `self::std` explicitly instead
= note: relative `use` paths enabled by `#![feature(uniform_paths)]`
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.

2
src/test/ui/rust-2018/uniform-paths/ambiguity.rs
View file

@ -13,7 +13,7 @@
#![feature(uniform_paths)] #![feature(uniform_paths)]
use std::io; use std::io;
//~^ ERROR `std` import is ambiguous //~^ ERROR `std` is ambiguous
mod std { mod std {
pub struct io; pub struct io;

20
src/test/ui/rust-2018/uniform-paths/ambiguity.stderr
View file

@ -1,16 +1,20 @@
error: `std` import is ambiguous error[E0659]: `std` is ambiguous (name vs any other name during import resolution)
--> $DIR/ambiguity.rs:15:5 --> $DIR/ambiguity.rs:15:5
| |
LL | use std::io; LL | use std::io;
| ^^^ can refer to external crate `::std` | ^^^ ambiguous name
... |
= note: `std` could refer to a built-in extern crate
= help: use `::std` to refer to the extern crate unambiguously
note: `std` could also refer to the module defined here
--> $DIR/ambiguity.rs:18:1
|
LL | / mod std { LL | / mod std {
LL | | pub struct io; LL | | pub struct io;
LL | | } LL | | }
| |_- can refer to `self::std` | |_^
| = help: use `self::std` to refer to the module unambiguously
= help: write `::std` or `self::std` explicitly instead
= note: relative `use` paths enabled by `#![feature(uniform_paths)]`
error: aborting due to previous error error: aborting due to previous error
For more information about this error, try `rustc --explain E0659`.