resolve: Improve diagnostics for resolution ambiguities

41 files changed, 604 insertions, 426 deletions

diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs
index e4c434b562d..c5e631ebafa 100644
--- a/src/librustc/hir/def.rs
+++ b/src/librustc/hir/def.rs
@@ -128,14 +128,6 @@ impl PathResolution {
     pub fn unresolved_segments(&self) -> usize {
         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.
@@ -333,4 +325,12 @@ impl Def {
             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",
+        }
+    }
 }
diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs
index 32f8752c31b..bafabe4e997 100644
--- a/src/librustc_mir/hair/pattern/check_match.rs
+++ b/src/librustc_mir/hair/pattern/check_match.rs
@@ -298,7 +298,8 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
             let label_msg = match pat.node {
                 PatKind::Path(hir::QPath::Resolved(None, ref path))
                         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),
             };
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index 777543bcf37..864aa7f6dc4 100644
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -347,6 +347,23 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 let used = self.process_legacy_macro_imports(item, module, &parent_scope);
                 let binding =
                     (module, ty::Visibility::Public, sp, expansion).to_name_binding(self.arenas);
+                let directive = self.arenas.alloc_import_directive(ImportDirective {
+                    root_id: item.id,
+                    id: item.id,
+                    parent_scope,
+                    imported_module: Cell::new(Some(ModuleOrUniformRoot::Module(module))),
+                    subclass: ImportDirectiveSubclass::ExternCrate {
+                        source: orig_name,
+                        target: ident,
+                    },
+                    root_span: item.span,
+                    span: item.span,
+                    module_path: Vec::new(),
+                    vis: Cell::new(vis),
+                    used: Cell::new(used),
+                });
+                self.potentially_unused_imports.push(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() &&
@@ -361,28 +378,11 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                         extern_crate_item: None,
                         introduced_by_item: true,
                     });
-                    entry.extern_crate_item = Some(binding);
+                    entry.extern_crate_item = Some(imported_binding);
                     if orig_name.is_some() {
                         entry.introduced_by_item = true;
                     }
                 }
-                let directive = self.arenas.alloc_import_directive(ImportDirective {
-                    root_id: item.id,
-                    id: item.id,
-                    parent_scope,
-                    imported_module: Cell::new(Some(ModuleOrUniformRoot::Module(module))),
-                    subclass: ImportDirectiveSubclass::ExternCrate {
-                        source: orig_name,
-                        target: ident,
-                    },
-                    root_span: item.span,
-                    span: item.span,
-                    module_path: Vec::new(),
-                    vis: Cell::new(vis),
-                    used: Cell::new(used),
-                });
-                self.potentially_unused_imports.push(directive);
-                let imported_binding = self.import(binding, directive);
                 self.define(parent, ident, TypeNS, imported_binding);
             }
 
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 279fbafdcd7..23fff0d0126 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -391,14 +391,13 @@ fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver,
             err
         }
         ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => {
-            let shadows_what = PathResolution::new(binding.def()).kind_name();
-            let mut err = struct_span_err!(resolver.session,
-                                           span,
-                                           E0530,
-                                           "{}s cannot shadow {}s", what_binding, shadows_what);
-            err.span_label(span, format!("cannot be named the same as a {}", shadows_what));
+            let (shadows_what, article) = (binding.descr(), binding.article());
+            let mut err = struct_span_err!(resolver.session, span, E0530, "{}s cannot shadow {}s",
+                                           what_binding, shadows_what);
+            err.span_label(span, format!("cannot be named the same as {} {}",
+                                         article, shadows_what));
             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
         }
@@ -1195,6 +1194,7 @@ enum NameBindingKind<'a> {
         used: Cell<bool>,
     },
     Ambiguity {
+        kind: AmbiguityKind,
         b1: &'a NameBinding<'a>,
         b2: &'a NameBinding<'a>,
     }
@@ -1212,10 +1212,61 @@ struct UseError<'a> {
     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> {
+    kind: AmbiguityKind,
     ident: Ident,
     b1: &'a NameBinding<'a>,
     b2: &'a NameBinding<'a>,
+    misc1: AmbiguityErrorMisc,
+    misc2: AmbiguityErrorMisc,
 }
 
 impl<'a> NameBinding<'a> {
@@ -1268,6 +1319,9 @@ impl<'a> NameBinding<'a> {
                     subclass: ImportDirectiveSubclass::ExternCrate { .. }, ..
                 }, ..
             } => true,
+            NameBindingKind::Module(
+                &ModuleData { kind: ModuleKind::Def(Def::Mod(def_id), _), .. }
+            ) => def_id.index == CRATE_DEF_INDEX,
             _ => false,
         }
     }
@@ -1313,6 +1367,10 @@ impl<'a> NameBinding<'a> {
         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`
     // 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
@@ -1885,8 +1943,12 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                 self.record_use(ident, ns, binding)
             }
             NameBindingKind::Import { .. } => false,
-            NameBindingKind::Ambiguity { b1, b2 } => {
-                self.ambiguity_errors.push(AmbiguityError { ident, b1, b2 });
+            NameBindingKind::Ambiguity { kind, b1, b2 } => {
+                self.ambiguity_errors.push(AmbiguityError {
+                    kind, ident, b1, b2,
+                    misc1: AmbiguityErrorMisc::None,
+                    misc2: AmbiguityErrorMisc::None,
+                });
                 true
             }
             _ => false
@@ -2024,7 +2086,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
             }
             if ns == TypeNS && is_known_tool(ident.name) {
                 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));
             }
             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) {
-        let participle = |is_import: bool| if is_import { "imported" } else { "defined" };
-        let msg1 =
-            format!("`{}` could refer to the name {} here", ident, participle(b1.is_import()));
-        let msg2 =
-            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))
+    fn report_ambiguity_error(&self, ambiguity_error: &AmbiguityError) {
+        let AmbiguityError { kind, ident, b1, b2, misc1, misc2 } = *ambiguity_error;
+        let (b1, b2, misc1, misc2, swapped) = if b2.span.is_dummy() && !b1.span.is_dummy() {
+            // We have to print the span-less alternative first, otherwise formatting looks bad.
+            (b2, b1, misc2, misc1, true)
         } 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_note(b1.span, &msg1);
-        match b2.def() {
-            Def::Macro(..) if b2.span.is_dummy() =>
-                err.note(&format!("`{}` is also a builtin macro", ident)),
-            _ => err.span_note(b2.span, &msg2),
+
+        let mut could_refer_to = |b: &NameBinding, misc: AmbiguityErrorMisc, also: &str| {
+            let what = if b.span.is_dummy() {
+                let add_built_in = match b.def() {
+                    // 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();
     }
 
@@ -4680,9 +4784,9 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
             );
         }
 
-        for &AmbiguityError { ident, b1, b2 } in &self.ambiguity_errors {
-            if reported_spans.insert(ident.span) {
-                self.report_ambiguity_error(ident, b1, b2);
+        for ambiguity_error in &self.ambiguity_errors {
+            if reported_spans.insert(ambiguity_error.ident.span) {
+                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 });
                 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))
             }
         })
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 05a2ad23e64..e38ffaca324 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use {AmbiguityError, CrateLint, Resolver, ResolutionError, is_known_tool, resolve_error};
-use {Module, ModuleKind, NameBinding, NameBindingKind, PathResult, Segment, ToNameBinding};
+use {AmbiguityError, AmbiguityKind, AmbiguityErrorMisc};
+use {CrateLint, Resolver, ResolutionError, is_known_tool, resolve_error};
+use {Module, ModuleKind, NameBinding, NameBindingKind, PathResult, ToNameBinding};
 use ModuleOrUniformRoot;
 use Namespace::{self, *};
 use build_reduced_graph::{BuildReducedGraphVisitor, IsMacroExport};
@@ -597,10 +598,11 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
 
         bitflags! {
             struct Flags: u8 {
-                const DERIVE_HELPERS = 1 << 0;
-                const MACRO_RULES    = 1 << 1;
-                const MODULE         = 1 << 2;
-                const PRELUDE        = 1 << 3;
+                const MACRO_RULES       = 1 << 0;
+                const MODULE            = 1 << 1;
+                const PRELUDE           = 1 << 2;
+                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
         // 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.
         let mut where_to_resolve = WhereToResolve::DeriveHelpers;
@@ -638,7 +640,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                                         (Def::NonMacroAttr(NonMacroAttrKind::DeriveHelper),
                                         ty::Visibility::Public, derive.span, Mark::root())
                                         .to_name_binding(self.arenas);
-                                    result = Ok((binding, Flags::DERIVE_HELPERS, Flags::all()));
+                                    result = Ok((binding, Flags::empty()));
                                     break;
                                 }
                             }
@@ -648,7 +650,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 }
                 WhereToResolve::MacroRules(legacy_scope) => match legacy_scope {
                     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),
                 }
                 WhereToResolve::Module(module) => {
@@ -662,29 +664,34 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                         path_span,
                     );
                     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 => {
                     let mut result = Err(Determinacy::Determined);
                     if use_prelude || self.session.rust_2015() {
                         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
                 }
                 WhereToResolve::BuiltinMacros => {
                     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),
                     }
                 }
                 WhereToResolve::BuiltinAttrs => {
                     if is_builtin_attr_name(ident.name) {
                         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);
-                        Ok((binding, Flags::PRELUDE, Flags::all()))
+                        Ok((binding, Flags::PRELUDE))
                     } else {
                         Err(Determinacy::Determined)
                     }
@@ -694,9 +701,9 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                        self.session.plugin_attributes.borrow().iter()
                                                      .any(|(name, _)| ident.name == &**name) {
                         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);
-                        Ok((binding, Flags::PRELUDE, Flags::PRELUDE))
+                        Ok((binding, Flags::PRELUDE))
                     } else {
                         Err(Determinacy::Determined)
                     }
@@ -706,7 +713,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     if use_prelude {
                         if let Some(binding) = self.extern_prelude_get(ident, !record_used,
                                                                        innermost_result.is_some()) {
-                            result = Ok((binding, Flags::PRELUDE, Flags::empty()));
+                            result = Ok((binding, Flags::PRELUDE));
                         }
                     }
                     result
@@ -714,8 +721,8 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 WhereToResolve::ToolPrelude => {
                     if use_prelude && is_known_tool(ident.name) {
                         let binding = (Def::ToolMod, ty::Visibility::Public,
-                                       ident.span, Mark::root()).to_name_binding(self.arenas);
-                        Ok((binding, Flags::PRELUDE, Flags::empty()))
+                                       DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
+                        Ok((binding, Flags::PRELUDE))
                     } else {
                         Err(Determinacy::Determined)
                     }
@@ -732,7 +739,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                                 false,
                                 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() {
                         Some(prim_ty) => {
                             let binding = (Def::PrimTy(prim_ty), ty::Visibility::Public,
-                                           ident.span, Mark::root()).to_name_binding(self.arenas);
-                            Ok((binding, Flags::PRELUDE, Flags::empty()))
+                                           DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
+                            Ok((binding, Flags::PRELUDE))
                         }
                         None => Err(Determinacy::Determined)
                     }
@@ -793,7 +800,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             }}
 
             match result {
-                Ok((binding, flags, ambig_flags)) => {
+                Ok((binding, flags)) => {
                     if sub_namespace_mismatch(macro_kind, binding.macro_kind()) {
                         continue_search!();
                     }
@@ -802,28 +809,61 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                         return Ok(binding);
                     }
 
-                    if let Some((innermost_binding, innermost_flags, innermost_ambig_flags))
-                            = innermost_result {
+                    if let Some((innermost_binding, innermost_flags)) = innermost_result {
                         // Found another solution, if the first one was "weak", report an error.
-                        if binding.def() != innermost_binding.def() &&
-                           (is_import ||
-                            innermost_binding.is_glob_import() ||
-                            innermost_binding.may_appear_after(parent_scope.expansion, binding) ||
-                            innermost_flags.intersects(ambig_flags) ||
-                            flags.intersects(innermost_ambig_flags) ||
-                            (innermost_flags.contains(Flags::MACRO_RULES) &&
-                             flags.contains(Flags::MODULE) &&
-                             !self.disambiguate_legacy_vs_modern(innermost_binding, binding))) {
-                            self.ambiguity_errors.push(AmbiguityError {
-                                ident,
-                                b1: innermost_binding,
-                                b2: binding,
-                            });
-                            return Ok(innermost_binding);
+                        let (def, innermost_def) = (binding.def(), innermost_binding.def());
+                        if def != innermost_def {
+                            let builtin = Def::NonMacroAttr(NonMacroAttrKind::Builtin);
+                            let derive_helper = Def::NonMacroAttr(NonMacroAttrKind::DeriveHelper);
+                            let legacy_helper =
+                                Def::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper);
+
+                            let ambiguity_error_kind = if is_import {
+                                Some(AmbiguityKind::Import)
+                            } else if innermost_def == builtin || def == builtin {
+                                Some(AmbiguityKind::BuiltinAttr)
+                            } else if innermost_def == derive_helper || def == derive_helper {
+                                Some(AmbiguityKind::DeriveHelper)
+                            } else if innermost_def == legacy_helper &&
+                                      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 {
                         // Found the first solution.
-                        innermost_result = Some((binding, flags, ambig_flags));
+                        innermost_result = Some((binding, flags));
                     }
 
                     continue_search!();
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index 60d6bb7bdc9..890655c398c 100644
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -10,7 +10,8 @@
 
 use self::ImportDirectiveSubclass::*;
 
-use {AmbiguityError, CrateLint, Module, ModuleOrUniformRoot, PerNS};
+use {AmbiguityError, AmbiguityKind, AmbiguityErrorMisc};
+use {CrateLint, Module, ModuleOrUniformRoot, PerNS};
 use Namespace::{self, TypeNS, MacroNS};
 use {NameBinding, NameBindingKind, ToNameBinding, PathResult, PrivacyError};
 use {Resolver, Segment};
@@ -219,7 +220,7 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
                 };
                 self.populate_module_if_necessary(crate_root);
                 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);
             }
         };
@@ -244,12 +245,14 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
                     // Forbid expanded shadowing to avoid time travel.
                     if restricted_shadowing &&
                        binding.expansion != Mark::root() &&
-                       ns != MacroNS && // In MacroNS, `try_define` always forbids this shadowing
                        binding.def() != shadowed_glob.def() {
                         self.ambiguity_errors.push(AmbiguityError {
+                            kind: AmbiguityKind::GlobVsExpanded,
                             ident,
                             b1: binding,
                             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.update_resolution(module, ident, ns, |this, resolution| {
             if let Some(old_binding) = resolution.binding {
-                if binding.is_glob_import() {
-                    if !old_binding.is_glob_import() &&
-                       !(ns == MacroNS && old_binding.expansion != Mark::root()) {
-                        resolution.shadowed_glob = Some(binding);
-                    } else if binding.def() != old_binding.def() {
-                        resolution.binding = Some(this.ambiguity(old_binding, binding));
-                    } else if !old_binding.vis.is_at_least(binding.vis, &*this) {
-                        // We are glob-importing the same item but with greater visibility.
-                        resolution.binding = Some(binding);
+                match (old_binding.is_glob_import(), binding.is_glob_import()) {
+                    (true, true) => {
+                        if binding.def() != old_binding.def() {
+                            resolution.binding = Some(this.ambiguity(AmbiguityKind::GlobVsGlob,
+                                                                     old_binding, binding));
+                        } else if !old_binding.vis.is_at_least(binding.vis, &*this) {
+                            // We are glob-importing the same item but with greater visibility.
+                            resolution.binding = Some(binding);
+                        }
                     }
-                } else if old_binding.is_glob_import() {
-                    if ns == MacroNS && binding.expansion != Mark::root() &&
-                       binding.def() != old_binding.def() {
-                        resolution.binding = Some(this.ambiguity(binding, old_binding));
-                    } else {
-                        resolution.binding = Some(binding);
-                        resolution.shadowed_glob = Some(old_binding);
+                    (old_glob @ true, false) | (old_glob @ false, true) => {
+                        let (glob_binding, nonglob_binding) = if old_glob {
+                            (old_binding, binding)
+                        } else {
+                            (binding, 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);
+                        }
+                    }
+                    (false, false) => {
+                        if let (&NameBindingKind::Def(_, true), &NameBindingKind::Def(_, true)) =
+                               (&old_binding.kind, &binding.kind) {
+
+                            this.session.buffer_lint_with_diagnostic(
+                                DUPLICATE_MACRO_EXPORTS,
+                                CRATE_NODE_ID,
+                                binding.span,
+                                &format!("a macro named `{}` has already been exported", ident),
+                                BuiltinLintDiagnostics::DuplicatedMacroExports(
+                                    ident, old_binding.span, binding.span));
+
+                            resolution.binding = Some(binding);
+                        } else {
+                            return Err(old_binding);
+                        }
                     }
-                } else if let (&NameBindingKind::Def(_, true), &NameBindingKind::Def(_, true)) =
-                        (&old_binding.kind, &binding.kind) {
-
-                    this.session.buffer_lint_with_diagnostic(
-                        DUPLICATE_MACRO_EXPORTS,
-                        CRATE_NODE_ID,
-                        binding.span,
-                        &format!("a macro named `{}` has already been exported", ident),
-                        BuiltinLintDiagnostics::DuplicatedMacroExports(
-                            ident, old_binding.span, binding.span));
-
-                    resolution.binding = Some(binding);
-                } else {
-                    return Err(old_binding);
                 }
             } else {
                 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> {
         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 },
             span: b1.span,
             expansion: Mark::root(),
diff --git a/src/test/ui-fulldeps/custom-derive/helper-attr-blocked-by-import-ambig.stderr b/src/test/ui-fulldeps/custom-derive/helper-attr-blocked-by-import-ambig.stderr
index 059629c0b62..fc55dc1eef6 100644
--- a/src/test/ui-fulldeps/custom-derive/helper-attr-blocked-by-import-ambig.stderr
+++ b/src/test/ui-fulldeps/custom-derive/helper-attr-blocked-by-import-ambig.stderr
@@ -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
    |
 LL | #[helper] //~ ERROR `helper` is ambiguous
    |   ^^^^^^ 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
    |
 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
    |
 LL | use plugin::helper;
    |     ^^^^^^^^^^^^^^
+   = help: use `self::helper` to refer to the attribute macro unambiguously
 
 error: aborting due to previous error
 
diff --git a/src/test/ui-fulldeps/proc-macro/ambiguous-builtin-attrs.stderr b/src/test/ui-fulldeps/proc-macro/ambiguous-builtin-attrs.stderr
index 0720ccb7cf9..00f5cfc2613 100644
--- a/src/test/ui-fulldeps/proc-macro/ambiguous-builtin-attrs.stderr
+++ b/src/test/ui-fulldeps/proc-macro/ambiguous-builtin-attrs.stderr
@@ -4,95 +4,75 @@ error[E0425]: cannot find value `NonExistent` in this scope
 LL |     NonExistent; //~ ERROR cannot find value `NonExistent` 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
    |
 LL | #[repr(C)] //~ ERROR `repr` is ambiguous
    |   ^^^^ 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
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
-note: `repr` could also refer to the name defined here
-  --> $DIR/ambiguous-builtin-attrs.rs:9:3
-   |
-LL | #[repr(C)] //~ ERROR `repr` is ambiguous
-   |   ^^^^
-   = note: consider adding an explicit import of `repr` to disambiguate
+   = help: use `self::repr` to refer to the attribute macro unambiguously
 
-error[E0659]: `repr` is ambiguous
+error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
   --> $DIR/ambiguous-builtin-attrs.rs:11:19
    |
 LL | #[cfg_attr(all(), repr(C))] //~ ERROR `repr` is ambiguous
    |                   ^^^^ 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
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
-note: `repr` could also refer to the name defined here
-  --> $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
+   = help: use `self::repr` to refer to the attribute macro unambiguously
 
-error[E0659]: `repr` is ambiguous
+error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
   --> $DIR/ambiguous-builtin-attrs.rs:20:34
    |
 LL | fn non_macro_expanded_location<#[repr(C)] T>() { //~ ERROR `repr` is ambiguous
    |                                  ^^^^ 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
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
-note: `repr` could also refer to the name defined here
-  --> $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
+   = help: use `self::repr` to refer to the attribute macro unambiguously
 
-error[E0659]: `repr` is ambiguous
+error[E0659]: `repr` is ambiguous (built-in attribute vs any other name)
   --> $DIR/ambiguous-builtin-attrs.rs:22:11
    |
 LL |         #[repr(C)] //~ ERROR `repr` is ambiguous
    |           ^^^^ 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
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
-note: `repr` could also refer to the name defined here
-  --> $DIR/ambiguous-builtin-attrs.rs:22:11
-   |
-LL |         #[repr(C)] //~ ERROR `repr` is ambiguous
-   |           ^^^^
-   = note: consider adding an explicit import of `repr` to disambiguate
+   = help: use `self::repr` to refer to the attribute macro unambiguously
 
-error[E0659]: `feature` is ambiguous
+error[E0659]: `feature` is ambiguous (built-in attribute vs any other name)
   --> $DIR/ambiguous-builtin-attrs.rs:3:4
    |
 LL | #![feature(decl_macro)] //~ ERROR `feature` is ambiguous
    |    ^^^^^^^ 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
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
-note: `feature` could also refer to the name defined here
-  --> $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
+   = help: use `self::feature` to refer to the attribute macro unambiguously
 
 error: aborting due to 6 previous errors
 
diff --git a/src/test/ui-fulldeps/proc-macro/derive-helper-shadowing.stderr b/src/test/ui-fulldeps/proc-macro/derive-helper-shadowing.stderr
index e0aeae4ba6c..4950b016d37 100644
--- a/src/test/ui-fulldeps/proc-macro/derive-helper-shadowing.stderr
+++ b/src/test/ui-fulldeps/proc-macro/derive-helper-shadowing.stderr
@@ -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
    |
 LL | #[my_attr] //~ ERROR `my_attr` is ambiguous
    |   ^^^^^^^ 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
    |
 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
    |
 LL | use derive_helper_shadowing::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use `self::my_attr` to refer to the attribute macro unambiguously
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/error-codes/E0659.stderr b/src/test/ui/error-codes/E0659.stderr
index f168b7797ca..7bfe159405b 100644
--- a/src/test/ui/error-codes/E0659.stderr
+++ b/src/test/ui/error-codes/E0659.stderr
@@ -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
    |
 LL |     collider::foo(); //~ ERROR E0659
    |               ^^^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/duplicate.stderr b/src/test/ui/imports/duplicate.stderr
index 5d51981e8af..f53ba9cd5de 100644
--- a/src/test/ui/imports/duplicate.stderr
+++ b/src/test/ui/imports/duplicate.stderr
@@ -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
    |         ^^^^^^^^^^^^^^^^^^^
 
-error[E0659]: `foo` is ambiguous
+error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
   --> $DIR/duplicate.rs:56:15
    |
 LL |     use self::foo::bar; //~ ERROR `foo` is ambiguous
    |               ^^^ 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
    |
 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
    |
 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
    |
 LL |     f::foo(); //~ ERROR `foo` is ambiguous
    |        ^^^ 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
    |
 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
    |
 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
    |
 LL |     g::foo(); //~ ERROR `foo` is ambiguous
    |        ^^^ 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
    |
 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
    |
 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
    |
 LL |         foo::bar(); //~ ERROR `foo` is ambiguous
    |         ^^^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr b/src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr
index 6c832e70e49..218dfb796f7 100644
--- a/src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr
+++ b/src/test/ui/imports/extern-prelude-extern-crate-restricted-shadowing.stderr
@@ -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
    |
 LL |         Vec::panic!(); //~ ERROR `Vec` is ambiguous
    |         ^^^ 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
    |
 LL |         extern crate std as Vec;
@@ -12,8 +13,6 @@ LL |         extern crate std as Vec;
 ...
 LL | define_vec!();
    | -------------- 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
 
diff --git a/src/test/ui/imports/glob-shadowing.stderr b/src/test/ui/imports/glob-shadowing.stderr
index 33a2963fa29..93d3fa969ef 100644
--- a/src/test/ui/imports/glob-shadowing.stderr
+++ b/src/test/ui/imports/glob-shadowing.stderr
@@ -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
    |
 LL |         let x = env!("PATH"); //~ ERROR `env` is ambiguous
    |                 ^^^ 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
    |
 LL |     use m::*;
    |         ^^^^
-   = note: `env` is also a builtin macro
-   = note: consider adding an explicit import of `env` to disambiguate
+   = help: 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
    |
 LL |             let x = env!("PATH"); //~ ERROR `env` is ambiguous
    |                     ^^^ 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
    |
 LL |         use m::*;
    |             ^^^^
-   = note: `env` is also a builtin macro
-   = note: consider adding an explicit import of `env` to disambiguate
+   = help: 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
    |
 LL |             let x = fenv!(); //~ ERROR `fenv` is ambiguous
    |                     ^^^^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/issue-53269.stderr b/src/test/ui/imports/issue-53269.stderr
index e125983151d..9fa438e91cd 100644
--- a/src/test/ui/imports/issue-53269.stderr
+++ b/src/test/ui/imports/issue-53269.stderr
@@ -4,22 +4,23 @@ error[E0432]: unresolved import `nonexistent_module`
 LL |     use nonexistent_module::mac; //~ ERROR unresolved import `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
    |
 LL |     mac!(); //~ ERROR `mac` is ambiguous
    |     ^^^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/local-modularized-tricky-fail-1.stderr b/src/test/ui/imports/local-modularized-tricky-fail-1.stderr
index 9c475451ce3..91e569d1764 100644
--- a/src/test/ui/imports/local-modularized-tricky-fail-1.stderr
+++ b/src/test/ui/imports/local-modularized-tricky-fail-1.stderr
@@ -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
    |
 LL | exported!(); //~ ERROR `exported` is ambiguous
    | ^^^^^^^^ 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
    |
 LL | /     macro_rules! exported {
@@ -14,20 +14,21 @@ LL | |     }
 ...
 LL |       define_exported!();
    |       ------------------- 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
    |
 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
    |
 LL | include!(); //~ ERROR `include` is ambiguous
    | ^^^^^^^ 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
    |
 LL | /     macro_rules! include {
@@ -37,16 +38,16 @@ LL | |     }
 ...
 LL |       define_include!();
    |       ------------------ in this macro invocation
-   = note: `include` is also a builtin macro
-   = note: macro-expanded macros do not shadow
+   = help: use `self::include` 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/local-modularized-tricky-fail-1.rs:45:5
    |
 LL |     panic!(); //~ ERROR `panic` is ambiguous
    |     ^^^^^ 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
    |
 LL | /     macro_rules! panic {
@@ -56,16 +57,16 @@ LL | |     }
 ...
 LL |       define_panic!();
    |       ---------------- in this macro invocation
-   = note: `panic` is also a builtin macro
-   = note: macro-expanded macros do not shadow
+   = help: 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)
   --> <::std::macros::panic macros>:1:13
    |
 LL | (  ) => ( { panic ! ( "explicit panic" ) } ) ; ( $ msg : expr ) => (
    |             ^^^^^ 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
    |
 LL | /     macro_rules! panic {
@@ -75,8 +76,7 @@ LL | |     }
 ...
 LL |       define_panic!();
    |       ---------------- in this macro invocation
-   = note: `panic` is also a builtin macro
-   = note: macro-expanded macros do not shadow
+   = help: use `self::panic` to refer to the macro unambiguously
 
 error: aborting due to 4 previous errors
 
diff --git a/src/test/ui/imports/macro-paths.stderr b/src/test/ui/imports/macro-paths.stderr
index a612c64c2f4..96880492e28 100644
--- a/src/test/ui/imports/macro-paths.stderr
+++ b/src/test/ui/imports/macro-paths.stderr
@@ -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
    |
 LL |     bar::m! { //~ ERROR ambiguous
    |     ^^^ 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
    |
 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
    |
 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
    |
 LL |     baz::m! { //~ ERROR ambiguous
    |     ^^^ 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
    |
 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
    |
 LL | / pub mod baz {
 LL | |     pub use two_macros::m;
 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
 
diff --git a/src/test/ui/imports/macros.stderr b/src/test/ui/imports/macros.stderr
index 209d449dfd8..ade49e6be24 100644
--- a/src/test/ui/imports/macros.stderr
+++ b/src/test/ui/imports/macros.stderr
@@ -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
    |
 LL |     m! { //~ ERROR ambiguous
    |     ^ 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
    |
 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
    |
 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
    |
 LL |         m! { //~ ERROR ambiguous
    |         ^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/rfc-1560-warning-cycle.stderr b/src/test/ui/imports/rfc-1560-warning-cycle.stderr
index 91af3a4b6ac..946dc084cd0 100644
--- a/src/test/ui/imports/rfc-1560-warning-cycle.stderr
+++ b/src/test/ui/imports/rfc-1560-warning-cycle.stderr
@@ -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
    |
 LL |         fn f(_: Foo) {} //~ ERROR `Foo` is ambiguous
    |                 ^^^ 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
    |
 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
    |
 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
 
diff --git a/src/test/ui/imports/shadow_builtin_macros.stderr b/src/test/ui/imports/shadow_builtin_macros.stderr
index 7e5ab0c5abe..4d6c1aa3ea5 100644
--- a/src/test/ui/imports/shadow_builtin_macros.stderr
+++ b/src/test/ui/imports/shadow_builtin_macros.stderr
@@ -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
    |
 LL |     fn f() { panic!(); } //~ ERROR ambiguous
    |              ^^^^^ 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
    |
 LL |     use foo::*;
    |         ^^^^^^
-   = note: `panic` is also a builtin macro
-   = note: consider adding an explicit import of `panic` to disambiguate
+   = help: 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
    |
 LL |     fn f() { panic!(); } //~ ERROR ambiguous
    |              ^^^^^ 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
    |
 LL |     ::two_macros::m!(use foo::panic;);
    |                          ^^^^^^^^^^
-   = note: `panic` is also a builtin macro
-   = note: macro-expanded macro imports do not shadow
+   = help: 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:43:5
    |
 LL |     panic!(); //~ ERROR `panic` is ambiguous
    |     ^^^^^ 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
    |
 LL |         macro_rules! panic { () => {} }
@@ -40,26 +42,25 @@ LL |         macro_rules! panic { () => {} }
 LL |     } }
 LL |     m!();
    |     ----- 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
    |
 LL |     n!(); //~ ERROR ambiguous
    |     ^ 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
    |
 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
    |
 LL | #[macro_use(n)]
    |             ^
-   = note: consider adding an explicit import of `n` to disambiguate
 
 error: aborting due to 4 previous errors
 
diff --git a/src/test/ui/macros/ambiguity-legacy-vs-modern.stderr b/src/test/ui/macros/ambiguity-legacy-vs-modern.stderr
index b5e1e751737..2785594585d 100644
--- a/src/test/ui/macros/ambiguity-legacy-vs-modern.stderr
+++ b/src/test/ui/macros/ambiguity-legacy-vs-modern.stderr
@@ -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
    |
 LL |         m!() //~ ERROR `m` is ambiguous
    |         ^ 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
    |
 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
    |
 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
    |
 LL |     m!() //~ ERROR `m` is ambiguous
    |     ^ 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
    |
 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
    |
 LL |     macro m() { 0 }
diff --git a/src/test/ui/macros/macro-path-prelude-shadowing.stderr b/src/test/ui/macros/macro-path-prelude-shadowing.stderr
index 688b9dc2797..3e0ea823642 100644
--- a/src/test/ui/macros/macro-path-prelude-shadowing.stderr
+++ b/src/test/ui/macros/macro-path-prelude-shadowing.stderr
@@ -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
    |
 LL |         std::panic!(); //~ ERROR `std` is ambiguous
    |         ^^^ 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
    |
 LL |     use m2::*; // glob-import user-defined `std`
    |         ^^^^^
-note: `std` could also refer to the name defined here
-   = note: consider adding an explicit import of `std` to disambiguate
+   = help: 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
 
diff --git a/src/test/ui/macros/macro-shadowing.stderr b/src/test/ui/macros/macro-shadowing.stderr
index d996f3a7041..6985dfcc6c2 100644
--- a/src/test/ui/macros/macro-shadowing.stderr
+++ b/src/test/ui/macros/macro-shadowing.stderr
@@ -9,13 +9,13 @@ LL | m1!();
    |
    = 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
    |
 LL | foo!(); //~ ERROR `foo` is ambiguous
    | ^^^ 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
    |
 LL |     macro_rules! foo { () => {} }
@@ -23,12 +23,11 @@ LL |     macro_rules! foo { () => {} }
 ...
 LL | m1!();
    | ------ 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
    |
 LL | macro_rules! foo { () => {} }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: macro-expanded macros do not shadow
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/macros/restricted-shadowing-legacy.stderr b/src/test/ui/macros/restricted-shadowing-legacy.stderr
index 9e0d40c44b6..2135d63c80e 100644
--- a/src/test/ui/macros/restricted-shadowing-legacy.stderr
+++ b/src/test/ui/macros/restricted-shadowing-legacy.stderr
@@ -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
    |
 LL |             m!(); //~ ERROR `m` is ambiguous
    |             ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -12,7 +12,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => {} }
@@ -20,15 +20,14 @@ LL |         macro_rules! m { () => {} }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
    |                                          ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -36,7 +35,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => {} }
@@ -44,15 +43,14 @@ LL |         macro_rules! m { () => {} }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         m!(); //~ ERROR `m` is ambiguous
    |         ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -60,7 +58,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => {} }
@@ -68,15 +66,14 @@ LL |         macro_rules! m { () => {} }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         m!(); //~ ERROR `m` is ambiguous
    |         ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -84,7 +81,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => { Wrong } }
@@ -92,15 +89,14 @@ LL |         macro_rules! m { () => { Wrong } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             m!(); //~ ERROR `m` is ambiguous
    |             ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -108,7 +104,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => { Wrong } }
@@ -116,15 +112,14 @@ LL |         macro_rules! m { () => { Wrong } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
    |                                          ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -132,7 +127,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! m { () => { Wrong } }
@@ -140,15 +135,14 @@ LL |         macro_rules! m { () => { Wrong } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         m!(); //~ ERROR `m` is ambiguous
    |         ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -156,7 +150,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             macro_rules! m { () => {} }
@@ -164,15 +158,14 @@ LL |             macro_rules! m { () => {} }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro_rules! gen_invoc { () => { m!() } } //~ ERROR `m` is ambiguous
    |                                          ^ 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
    |
 LL |         macro_rules! m { () => { Right } }
@@ -180,7 +173,7 @@ LL |         macro_rules! m { () => { Right } }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             macro_rules! m { () => {} }
@@ -188,7 +181,6 @@ LL |             macro_rules! m { () => {} }
 ...
 LL | include!();
    | ----------- in this macro invocation
-   = note: macro-expanded macros do not shadow
 
 error: aborting due to 8 previous errors
 
diff --git a/src/test/ui/macros/restricted-shadowing-modern.stderr b/src/test/ui/macros/restricted-shadowing-modern.stderr
index 0462438be78..2449e8512d3 100644
--- a/src/test/ui/macros/restricted-shadowing-modern.stderr
+++ b/src/test/ui/macros/restricted-shadowing-modern.stderr
@@ -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
    |
 LL |                 m!(); //~ ERROR `m` is ambiguous
    |                 ^ 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
    |
 LL |         macro m() { Right }
@@ -12,7 +12,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() {}
@@ -20,15 +20,14 @@ LL |         macro m() {}
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
    |                                 ^ 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
    |
 LL |         macro m() { Right }
@@ -36,7 +35,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() {}
@@ -44,15 +43,14 @@ LL |         macro m() {}
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             m!(); //~ ERROR `m` is ambiguous
    |             ^ 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
    |
 LL |         macro m() { Right }
@@ -60,7 +58,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() {}
@@ -68,15 +66,14 @@ LL |         macro m() {}
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             m!(); //~ ERROR `m` is ambiguous
    |             ^ 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
    |
 LL |         macro m() { Right }
@@ -84,7 +81,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() { Wrong }
@@ -92,15 +89,14 @@ LL |         macro m() { Wrong }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |                 m!(); //~ ERROR `m` is ambiguous
    |                 ^ 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
    |
 LL |         macro m() { Right }
@@ -108,7 +104,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() { Wrong }
@@ -116,15 +112,14 @@ LL |         macro m() { Wrong }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |             macro gen_invoc() { m!() } //~ ERROR `m` is ambiguous
    |                                 ^ 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
    |
 LL |         macro m() { Right }
@@ -132,7 +127,7 @@ LL |         macro m() { Right }
 ...
 LL | include!();
    | ----------- 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
    |
 LL |         macro m() { Wrong }
@@ -140,7 +135,6 @@ LL |         macro m() { Wrong }
 ...
 LL | include!();
    | ----------- in this macro invocation
-   = note: macro-expanded macros do not shadow
 
 error: aborting due to 6 previous errors
 
diff --git a/src/test/ui/out-of-order-shadowing.stderr b/src/test/ui/out-of-order-shadowing.stderr
index d96a802cb3f..4696e205728 100644
--- a/src/test/ui/out-of-order-shadowing.stderr
+++ b/src/test/ui/out-of-order-shadowing.stderr
@@ -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
    |
 LL | bar!(); //~ ERROR `bar` is ambiguous
    | ^^^ 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
    |
 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
    |
 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)
 
 error: aborting due to previous error
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs
index 590e83b0781..4819711115c 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs
@@ -14,7 +14,7 @@
 
 mod foo {
     pub use std::io;
-    //~^ ERROR `std` import is ambiguous
+    //~^ ERROR `std` is ambiguous
 
     macro_rules! m {
         () => {
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr
index 948043cff76..b8cbabeea2c 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr
@@ -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
    |
-LL |       pub use std::io;
-   |               ^^^ can refer to external crate `::std`
-...
+LL |     pub use std::io;
+   |             ^^^ 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 | |                 pub struct io;
 LL | |             }
-   | |_____________- may refer to `self::std` in the future
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: in the future, `#![feature(uniform_paths)]` may become the default
+   | |_____________^
+...
+LL |       m!();
+   |       ----- in this macro invocation
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs
index 861efba14f8..148320de556 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs
@@ -13,7 +13,7 @@
 // This test is similar to `ambiguity.rs`, but with macros defining local items.
 
 use std::io;
-//~^ ERROR `std` import is ambiguous
+//~^ ERROR `std` is ambiguous
 
 macro_rules! m {
     () => {
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr
index 40cceea2440..5c9ab110854 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr
@@ -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
    |
-LL |   use std::io;
-   |       ^^^ can refer to external crate `::std`
-...
+LL | use std::io;
+   |     ^^^ 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 | |             pub struct io;
 LL | |         }
-   | |_________- may refer to `self::std` in the future
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: in the future, `#![feature(uniform_paths)]` may become the default
+   | |_________^
+...
+LL |   m!();
+   |   ----- in this macro invocation
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs
index a69eb101917..2791d4580da 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs
@@ -14,7 +14,7 @@
 
 mod foo {
     pub use std::io;
-    //~^ ERROR `std` import is ambiguous
+    //~^ ERROR `std` is ambiguous
 
     mod std {
         pub struct io;
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr
index 7538d3d2d91..e98b9ad9a2a 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr
@@ -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
    |
-LL |       pub use std::io;
-   |               ^^^ can refer to external crate `::std`
-...
+LL |     pub use std::io;
+   |             ^^^ 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 | |         pub struct io;
 LL | |     }
-   | |_____- may refer to `self::std` in the future
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: in the future, `#![feature(uniform_paths)]` may become the default
+   | |_____^
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs
index 500e9f6c63f..2bfbb6b2871 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs
@@ -11,7 +11,7 @@
 // edition:2018
 
 use std::io;
-//~^ ERROR `std` import is ambiguous
+//~^ ERROR `std` is ambiguous
 
 mod std {
     pub struct io;
diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr
index 7b64b8f0246..75387454015 100644
--- a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr
+++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr
@@ -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
    |
-LL |   use std::io;
-   |       ^^^ can refer to external crate `::std`
-...
+LL | use std::io;
+   |     ^^^ 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 | |     pub struct io;
 LL | | }
-   | |_- may refer to `self::std` in the future
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: in the future, `#![feature(uniform_paths)]` may become the default
+   | |_^
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.rs b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.rs
index e0992c90666..9f440d71fb0 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.rs
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.rs
@@ -16,7 +16,7 @@
 
 mod foo {
     pub use std::io;
-    //~^ ERROR `std` import is ambiguous
+    //~^ ERROR `std` is ambiguous
 
     macro_rules! m {
         () => {
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
index 154ee412e72..f18de7edcdc 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
@@ -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
    |
-LL |       pub use std::io;
-   |               ^^^ can refer to external crate `::std`
-...
+LL |     pub use std::io;
+   |             ^^^ 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 | |                 pub struct io;
 LL | |             }
-   | |_____________- can refer to `self::std`
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: relative `use` paths enabled by `#![feature(uniform_paths)]`
+   | |_____________^
+...
+LL |       m!();
+   |       ----- in this macro invocation
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.rs b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.rs
index 9439d92aa71..f1ed48150c0 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.rs
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.rs
@@ -15,7 +15,7 @@
 // This test is similar to `ambiguity.rs`, but with macros defining local items.
 
 use std::io;
-//~^ ERROR `std` import is ambiguous
+//~^ ERROR `std` is ambiguous
 
 macro_rules! m {
     () => {
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.stderr b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
index 3c0d5601f9c..16e083b0980 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
@@ -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
    |
-LL |   use std::io;
-   |       ^^^ can refer to external crate `::std`
-...
+LL | use std::io;
+   |     ^^^ 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 | |             pub struct io;
 LL | |         }
-   | |_________- can refer to `self::std`
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: relative `use` paths enabled by `#![feature(uniform_paths)]`
+   | |_________^
+...
+LL |   m!();
+   |   ----- in this macro invocation
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.rs b/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.rs
index 1756acc6057..0d0d34df1f8 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.rs
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.rs
@@ -16,7 +16,7 @@
 
 mod foo {
     pub use std::io;
-    //~^ ERROR `std` import is ambiguous
+    //~^ ERROR `std` is ambiguous
 
     mod std {
         pub struct io;
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.stderr b/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.stderr
index a607eeb0b43..cb38102c599 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.stderr
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity-nested.stderr
@@ -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
    |
-LL |       pub use std::io;
-   |               ^^^ can refer to external crate `::std`
-...
+LL |     pub use std::io;
+   |             ^^^ 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 | |         pub struct io;
 LL | |     }
-   | |_____- can refer to `self::std`
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: relative `use` paths enabled by `#![feature(uniform_paths)]`
+   | |_____^
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity.rs b/src/test/ui/rust-2018/uniform-paths/ambiguity.rs
index 9ae3d79c22c..259f451e4d2 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity.rs
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity.rs
@@ -13,7 +13,7 @@
 #![feature(uniform_paths)]
 
 use std::io;
-//~^ ERROR `std` import is ambiguous
+//~^ ERROR `std` is ambiguous
 
 mod std {
     pub struct io;
diff --git a/src/test/ui/rust-2018/uniform-paths/ambiguity.stderr b/src/test/ui/rust-2018/uniform-paths/ambiguity.stderr
index c65db3072f4..ce0c64b226b 100644
--- a/src/test/ui/rust-2018/uniform-paths/ambiguity.stderr
+++ b/src/test/ui/rust-2018/uniform-paths/ambiguity.stderr
@@ -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
    |
-LL |   use std::io;
-   |       ^^^ can refer to external crate `::std`
-...
+LL | use std::io;
+   |     ^^^ 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 | |     pub struct io;
 LL | | }
-   | |_- can refer to `self::std`
-   |
-   = help: write `::std` or `self::std` explicitly instead
-   = note: relative `use` paths enabled by `#![feature(uniform_paths)]`
+   | |_^
+   = help: use `self::std` to refer to the module unambiguously
 
 error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0659`.