resolve: Remove artificial import ambiguity errors

compiler/rustc_resolve/src/diagnostics.rs

@@ -1403,7 +1403,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] {
  if let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
  ident,
- ScopeSet::All(ns, false),
+ ScopeSet::All(ns),
  &parent_scope,
  None,
  false,
@@ -1841,10 +1841,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  _ => None,
  }
  } else {
- let scopes = ScopeSet::All(ns_to_try, opt_ns.is_none());
  self.early_resolve_ident_in_lexical_scope(
  ident,
- scopes,
+ ScopeSet::All(ns_to_try),
  parent_scope,
  None,
  false,

compiler/rustc_resolve/src/ident.rs

@@ -88,7 +88,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
  let rust_2015 = ctxt.edition().is_rust_2015();
  let (ns, macro_kind, is_absolute_path) = match scope_set {
- ScopeSet::All(ns, _) => (ns, None, false),
+ ScopeSet::All(ns) => (ns, None, false),
  ScopeSet::AbsolutePath(ns) => (ns, None, true),
  ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind), false),
  ScopeSet::Late(ns, ..) => (ns, None, false),
@@ -397,11 +397,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  return Err(Determinacy::Determined);
  }
 
- let (ns, macro_kind, is_import) = match scope_set {
- ScopeSet::All(ns, is_import) => (ns, None, is_import),
- ScopeSet::AbsolutePath(ns) => (ns, None, false),
- ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind), false),
- ScopeSet::Late(ns, ..) => (ns, None, false),
+ let (ns, macro_kind) = match scope_set {
+ ScopeSet::All(ns) => (ns, None),
+ ScopeSet::AbsolutePath(ns) => (ns, None),
+ ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind)),
+ ScopeSet::Late(ns, ..) => (ns, None),
  };
 
  // This is *the* result, resolution from the scope closest to the resolved identifier.
@@ -631,9 +631,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  let derive_helper_compat =
  Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat);
 
- let ambiguity_error_kind = if is_import {
- Some(AmbiguityKind::Import)
- } else if is_builtin(innermost_res) || is_builtin(res) {
+ let ambiguity_error_kind = if is_builtin(innermost_res)
+ || is_builtin(res)
+ {
  Some(AmbiguityKind::BuiltinAttr)
  } else if innermost_res == derive_helper_compat
  || res == derive_helper_compat && innermost_res != derive_helper
@@ -853,10 +853,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  }
  }
 
- let scopes = ScopeSet::All(ns, true);
  let binding = self.early_resolve_ident_in_lexical_scope(
  ident,
- scopes,
+ ScopeSet::All(ns),
  parent_scope,
  finalize,
  finalize.is_some(),
@@ -1497,7 +1496,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  } else {
  self.early_resolve_ident_in_lexical_scope(
  ident,
- ScopeSet::All(ns, opt_ns.is_none()),
+ ScopeSet::All(ns),
  parent_scope,
  finalize,
  finalize.is_some(),

compiler/rustc_resolve/src/imports.rs

@@ -10,10 +10,7 @@ use crate::errors::{
 use crate::Determinacy::{self, *};
 use crate::{fluent_generated as fluent, Namespace::*};
 use crate::{module_to_string, names_to_string, ImportSuggestion};
-use crate::{
- AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingKey, ModuleKind, ResolutionError,
- Resolver, Segment,
-};
+use crate::{AmbiguityKind, BindingKey, ModuleKind, ResolutionError, Resolver, Segment};
 use crate::{Finalize, Module, ModuleOrUniformRoot, ParentScope, PerNS, ScopeSet};
 use crate::{NameBinding, NameBindingKind, PathResult};
 
@@ -984,7 +981,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  match binding {
  Ok(binding) => {
  // Consistency checks, analogous to `finalize_macro_resolutions`.
- let initial_binding = source_bindings[ns].get().map(|initial_binding| {
+ let initial_res = source_bindings[ns].get().map(|initial_binding| {
  all_ns_err = false;
  if let Some(target_binding) = target_bindings[ns].get() {
  if target.name == kw::Underscore
@@ -998,20 +995,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  );
  }
  }
- initial_binding
+ initial_binding.res()
  });
  let res = binding.res();
- if let Ok(initial_binding) = initial_binding {
- let initial_res = initial_binding.res();
+ if let Ok(initial_res) = initial_res {
  if res != initial_res && this.ambiguity_errors.is_empty() {
- this.ambiguity_errors.push(AmbiguityError {
- kind: AmbiguityKind::Import,
- ident,
- b1: initial_binding,
- b2: binding,
- misc1: AmbiguityErrorMisc::None,
- misc2: AmbiguityErrorMisc::None,
- });
+ span_bug!(import.span, "inconsistent resolution for an import");
  }
  } else if res != Res::Err
  && this.ambiguity_errors.is_empty()
@@ -1283,7 +1272,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
  match this.early_resolve_ident_in_lexical_scope(
  target,
- ScopeSet::All(ns, false),
+ ScopeSet::All(ns),
  &import.parent_scope,
  None,
  false,

compiler/rustc_resolve/src/lib.rs

@@ -131,7 +131,7 @@ enum Scope<'a> {
 #[derive(Clone, Copy)]
 enum ScopeSet<'a> {
  /// All scopes with the given namespace.
- All(Namespace, /*is_import*/ bool),
+ All(Namespace),
  /// Crate root, then extern prelude (used for mixed 2015-2018 mode in macros).
  AbsolutePath(Namespace),
  /// All scopes with macro namespace and the given macro kind restriction.
@@ -718,7 +718,6 @@ struct UseError<'a> {
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum AmbiguityKind {
- Import,
  BuiltinAttr,
  DeriveHelper,
  MacroRulesVsModularized,
@@ -731,7 +730,6 @@ enum AmbiguityKind {
 impl AmbiguityKind {
  fn descr(self) -> &'static str {
  match self {
- AmbiguityKind::Import => "multiple potential import sources",
  AmbiguityKind::BuiltinAttr => "a name conflict with a builtin attribute",
  AmbiguityKind::DeriveHelper => "a name conflict with a derive helper attribute",
  AmbiguityKind::MacroRulesVsModularized => {
@@ -1557,7 +1555,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  }
  }
 
- self.visit_scopes(ScopeSet::All(TypeNS, false), parent_scope, ctxt, |this, scope, _, _| {
+ self.visit_scopes(ScopeSet::All(TypeNS), parent_scope, ctxt, |this, scope, _, _| {
  match scope {
  Scope::Module(module, _) => {
  this.traits_in_module(module, assoc_item, &mut found_traits);

compiler/rustc_resolve/src/macros.rs

@@ -645,7 +645,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  self.prohibit_imported_non_macro_attrs(None, res.ok(), path_span);
  res
  } else {
- let scope_set = kind.map_or(ScopeSet::All(MacroNS, false), ScopeSet::Macro);
+ let scope_set = kind.map_or(ScopeSet::All(MacroNS), ScopeSet::Macro);
  let binding = self.early_resolve_ident_in_lexical_scope(
  path[0].ident,
  scope_set,

tests/ui/imports/issue-56125.stderr

@@ -22,47 +22,50 @@ error[E0659]: `issue_56125` is ambiguous
 LL | use issue_56125::last_segment::*;
  | ^^^^^^^^^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
  = note: `issue_56125` could refer to a crate passed with `--extern`
  = help: use `::issue_56125` to refer to this crate unambiguously
 note: `issue_56125` could also refer to the module imported here
  --> $DIR/issue-56125.rs:6:9
  |
 LL | use issue_56125::last_segment::*;
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = help: use `self::issue_56125` to refer to this module unambiguously
+ = help: consider adding an explicit import of `issue_56125` to disambiguate
+ = help: or use `self::issue_56125` to refer to this module unambiguously
 
 error[E0659]: `issue_56125` is ambiguous
  --> $DIR/issue-56125.rs:11:9
  |
 LL | use issue_56125::non_last_segment::non_last_segment::*;
  | ^^^^^^^^^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
  = note: `issue_56125` could refer to a crate passed with `--extern`
  = help: use `::issue_56125` to refer to this crate unambiguously
 note: `issue_56125` could also refer to the module imported here
  --> $DIR/issue-56125.rs:11:9
  |
 LL | use issue_56125::non_last_segment::non_last_segment::*;
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = help: use `self::issue_56125` to refer to this module unambiguously
+ = help: consider adding an explicit import of `issue_56125` to disambiguate
+ = help: or use `self::issue_56125` to refer to this module unambiguously
 
 error[E0659]: `issue_56125` is ambiguous
  --> $DIR/issue-56125.rs:18:9
  |
 LL | use issue_56125::*;
  | ^^^^^^^^^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
  = note: `issue_56125` could refer to a crate passed with `--extern`
  = help: use `::issue_56125` to refer to this crate unambiguously
 note: `issue_56125` could also refer to the module imported here
  --> $DIR/issue-56125.rs:18:9
  |
 LL | use issue_56125::*;
  | ^^^^^^^^^^^^^^
- = help: use `self::issue_56125` to refer to this module unambiguously
+ = help: consider adding an explicit import of `issue_56125` to disambiguate
+ = help: or use `self::issue_56125` to refer to this module unambiguously
 
 error: aborting due to 4 previous errors
 

tests/ui/imports/issue-57539.stderr

@@ -4,15 +4,16 @@ error[E0659]: `core` is ambiguous
 LL | use core;
  | ^^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
  = note: `core` could refer to a built-in crate
  = help: use `::core` to refer to this crate unambiguously
 note: `core` could also refer to the module imported here
  --> $DIR/issue-57539.rs:5:9
  |
 LL | use crate::*;
  | ^^^^^^^^
- = help: use `self::core` to refer to this module unambiguously
+ = help: consider adding an explicit import of `core` to disambiguate
+ = help: or use `self::core` to refer to this module unambiguously
 
 error: aborting due to previous error
 

tests/ui/proc-macro/derive-helper-shadowing.rs

@@ -23,7 +23,7 @@ macro_rules! gen_helper_use {
 struct S {
  #[empty_helper] // OK, no ambiguity, derive helpers have highest priority
  field: [u8; {
- use empty_helper; //~ ERROR `empty_helper` is ambiguous
+ use empty_helper; // OK, no ambiguity, derive helpers have highest priority
 
  #[empty_helper] // OK, no ambiguity, derive helpers have highest priority
  struct U;

tests/ui/proc-macro/derive-helper-shadowing.stderr

@@ -37,25 +37,6 @@ help: consider importing this attribute macro through its public re-export
 LL + use crate::empty_helper;
  |
 
-error[E0659]: `empty_helper` is ambiguous
- --> $DIR/derive-helper-shadowing.rs:26:13
- |
-LL | use empty_helper;
- | ^^^^^^^^^^^^ ambiguous name
- |
- = note: ambiguous because of multiple potential import sources
-note: `empty_helper` could refer to the derive helper attribute defined here
- --> $DIR/derive-helper-shadowing.rs:22:10
- |
-LL | #[derive(Empty)]
- | ^^^^^
-note: `empty_helper` could also refer to the attribute macro imported here
- --> $DIR/derive-helper-shadowing.rs:10:5
- |
-LL | use test_macros::empty_attr as empty_helper;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = help: use `crate::empty_helper` to refer to this attribute macro unambiguously
-
 error[E0659]: `empty_helper` is ambiguous
  --> $DIR/derive-helper-shadowing.rs:19:3
  |
@@ -88,6 +69,6 @@ LL | #[derive(Empty)]
  = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
  = note: `#[warn(legacy_derive_helpers)]` on by default
 
-error: aborting due to 5 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0659`.

tests/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr

@@ -4,7 +4,7 @@ error[E0659]: `std` is ambiguous
 LL | pub use std::io;
  | ^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
  = note: `std` could refer to a built-in crate
  = help: use `::std` to refer to this crate unambiguously
 note: `std` could also refer to the module defined here

tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr

@@ -4,7 +4,7 @@ error[E0659]: `std` is ambiguous
 LL | use std::io;
  | ^^^ ambiguous name
  |
- = note: ambiguous because of multiple potential import sources
+ = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
  = note: `std` could refer to a built-in crate
  = help: use `::std` to refer to this crate unambiguously
 note: `std` could also refer to the module defined here

tests/ui/rust-2018/uniform-paths/ambiguity-nested.rs

@@ -1,12 +1,12 @@
+// check-pass
 // edition:2018
 
 // This test is similar to `ambiguity.rs`, but nested in a module.
 
 #![allow(non_camel_case_types)]
 
 mod foo {
- pub use std::io;
- //~^ ERROR `std` is ambiguous
+ pub use std::io; // OK
 
  mod std {
  pub struct io;

tests/ui/rust-2018/uniform-paths/ambiguity.rs

@@ -1,9 +1,9 @@
+// check-pass
 // edition:2018
 
 #![allow(non_camel_case_types)]
 
-use std::io;
-//~^ ERROR `std` is ambiguous
+use std::io; // OK
 
 mod std {
  pub struct io;

tests/ui/rust-2018/uniform-paths/block-scoped-shadow-nested.rs

@@ -1,3 +1,4 @@
+// check-pass
 // edition:2018
 
 mod my {
@@ -13,7 +14,7 @@ mod sub {
 fn foo() {
  use my::sub;
  {
- use sub::bar; //~ ERROR `sub` is ambiguous
+ use sub::bar; // OK
  }
 }