metadata: Stop keeping AmbiguityKind in name bindings

It can only be `GlobVsGlob` now.

Author: petrochenkov

compiler/rustc_middle/src/metadata.rs

@@ -45,16 +45,9 @@ pub struct ModChild {
     pub reexport_chain: SmallVec<[Reexport; 2]>,
 }
 
-#[derive(Debug, TyEncodable, TyDecodable, HashStable)]
-pub enum AmbigModChildKind {
-    GlobVsGlob,
-    GlobVsExpanded,
-}
-
 /// Same as `ModChild`, however, it includes ambiguity error.
 #[derive(Debug, TyEncodable, TyDecodable, HashStable)]
 pub struct AmbigModChild {
     pub main: ModChild,
     pub second: ModChild,
-    pub kind: AmbigModChildKind,
 }

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -22,7 +22,7 @@ use rustc_hir::def::{self, *};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_metadata::creader::LoadedMacro;
-use rustc_middle::metadata::{AmbigModChildKind, ModChild, Reexport};
+use rustc_middle::metadata::{ModChild, Reexport};
 use rustc_middle::ty::{Feed, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
@@ -36,9 +36,9 @@ use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::ref_mut::CmCell;
 use crate::{
-    AmbiguityKind, BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind,
-    ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
-    ResolutionError, Resolver, Segment, Used, VisResolutionError, errors,
+    BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
+    NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult, ResolutionError,
+    Resolver, Segment, Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -82,7 +82,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         vis: Visibility<DefId>,
         span: Span,
         expansion: LocalExpnId,
-        ambiguity: Option<(NameBinding<'ra>, AmbiguityKind)>,
+        ambiguity: Option<NameBinding<'ra>>,
     ) {
         let binding = self.arenas.alloc_name_binding(NameBindingData {
             kind: NameBindingKind::Res(res),
@@ -254,7 +254,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 &child.main,
                 parent_scope,
                 children.len() + i,
-                Some((&child.second, child.kind)),
+                Some(&child.second),
             )
         }
     }
@@ -265,7 +265,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         child: &ModChild,
         parent_scope: ParentScope<'ra>,
         child_index: usize,
-        ambig_child: Option<(&ModChild, AmbigModChildKind)>,
+        ambig_child: Option<&ModChild>,
     ) {
         let parent = parent_scope.module;
         let child_span = |this: &Self, reexport_chain: &[Reexport], res: def::Res<_>| {
@@ -280,15 +280,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let span = child_span(self, reexport_chain, res);
         let res = res.expect_non_local();
         let expansion = parent_scope.expansion;
-        let ambig = ambig_child.map(|(ambig_child, ambig_kind)| {
+        let ambig = ambig_child.map(|ambig_child| {
             let ModChild { ident: _, res, vis, ref reexport_chain } = *ambig_child;
             let span = child_span(self, reexport_chain, res);
             let res = res.expect_non_local();
-            let ambig_kind = match ambig_kind {
-                AmbigModChildKind::GlobVsGlob => AmbiguityKind::GlobVsGlob,
-                AmbigModChildKind::GlobVsExpanded => AmbiguityKind::GlobVsExpanded,
-            };
-            (self.arenas.new_res_binding(res, vis, span, expansion), ambig_kind)
+            self.arenas.new_res_binding(res, vis, span, expansion)
         });
 
         // Record primary definitions.

compiler/rustc_resolve/src/imports.rs

@@ -9,7 +9,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir::def::{self, DefKind, PartialRes};
 use rustc_hir::def_id::{DefId, LocalDefIdMap};
-use rustc_middle::metadata::{AmbigModChild, AmbigModChildKind, ModChild, Reexport};
+use rustc_middle::metadata::{AmbigModChild, ModChild, Reexport};
 use rustc_middle::span_bug;
 use rustc_middle::ty::Visibility;
 use rustc_session::lint::BuiltinLintDiag;
@@ -32,10 +32,9 @@ use crate::errors::{
 };
 use crate::ref_mut::CmCell;
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingKey, CmResolver, Determinacy, Finalize, ImportSuggestion,
-    Module, ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope,
-    PathResult, PerNS, ResolutionError, Resolver, ScopeSet, Segment, Used, module_to_string,
-    names_to_string,
+    AmbiguityError, BindingKey, CmResolver, Determinacy, Finalize, ImportSuggestion, Module,
+    ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
+    PerNS, ResolutionError, Resolver, ScopeSet, Segment, Used, module_to_string, names_to_string,
 };
 
 type Res = def::Res<NodeId>;
@@ -373,7 +372,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             resolution.glob_binding = Some(glob_binding);
                         } else if res != old_glob_binding.res() {
                             resolution.glob_binding = Some(this.new_ambiguity_binding(
-                                AmbiguityKind::GlobVsGlob,
                                 old_glob_binding,
                                 glob_binding,
                                 warn_ambiguity,
@@ -394,7 +392,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             assert!(old_glob_binding.is_glob_import());
                             if glob_binding.res() != old_glob_binding.res() {
                                 resolution.glob_binding = Some(this.new_ambiguity_binding(
-                                    AmbiguityKind::GlobVsGlob,
                                     old_glob_binding,
                                     glob_binding,
                                     false,
@@ -424,12 +421,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     fn new_ambiguity_binding(
         &self,
-        ambiguity_kind: AmbiguityKind,
         primary_binding: NameBinding<'ra>,
         secondary_binding: NameBinding<'ra>,
         warn_ambiguity: bool,
     ) -> NameBinding<'ra> {
-        let ambiguity = Some((secondary_binding, ambiguity_kind));
+        let ambiguity = Some(secondary_binding);
         let data = NameBindingData { ambiguity, warn_ambiguity, ..*primary_binding };
         self.arenas.alloc_name_binding(data)
     }
@@ -645,7 +641,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 let Some(binding) = resolution.best_binding() else { continue };
 
                 if let NameBindingKind::Import { import, .. } = binding.kind
-                    && let Some((amb_binding, _)) = binding.ambiguity
+                    && let Some(amb_binding) = binding.ambiguity
                     && binding.res() != Res::Err
                     && exported_ambiguities.contains(&binding)
                 {
@@ -1553,23 +1549,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     vis: binding.vis,
                     reexport_chain,
                 };
-                if let Some((ambig_binding1, ambig_binding2, ambig_kind)) =
-                    binding.descent_to_ambiguity()
-                {
+                if let Some((ambig_binding1, ambig_binding2)) = binding.descent_to_ambiguity() {
                     let main = child(ambig_binding1.reexport_chain(this));
                     let second = ModChild {
                         ident: ident.0,
                         res: ambig_binding2.res().expect_non_local(),
                         vis: ambig_binding2.vis,
                         reexport_chain: ambig_binding2.reexport_chain(this),
                     };
-                    let kind = match ambig_kind {
-                        AmbiguityKind::GlobVsGlob => AmbigModChildKind::GlobVsGlob,
-                        AmbiguityKind::GlobVsExpanded => AmbigModChildKind::GlobVsExpanded,
-                        _ => unreachable!(),
-                    };
-
-                    ambig_children.push(AmbigModChild { main, second, kind })
+                    ambig_children.push(AmbigModChild { main, second })
                 } else {
                     children.push(child(binding.reexport_chain(this)));
                 }

compiler/rustc_resolve/src/lib.rs

@@ -807,7 +807,7 @@ impl<'ra> fmt::Debug for Module<'ra> {
 #[derive(Clone, Copy, Debug)]
 struct NameBindingData<'ra> {
     kind: NameBindingKind<'ra>,
-    ambiguity: Option<(NameBinding<'ra>, AmbiguityKind)>,
+    ambiguity: Option<NameBinding<'ra>>,
     /// Produce a warning instead of an error when reporting ambiguities inside this binding.
     /// May apply to indirect ambiguities under imports, so `ambiguity.is_some()` is not required.
     warn_ambiguity: bool,
@@ -937,9 +937,9 @@ impl<'ra> NameBindingData<'ra> {
 
     fn descent_to_ambiguity(
         self: NameBinding<'ra>,
-    ) -> Option<(NameBinding<'ra>, NameBinding<'ra>, AmbiguityKind)> {
+    ) -> Option<(NameBinding<'ra>, NameBinding<'ra>)> {
         match self.ambiguity {
-            Some((ambig_binding, ambig_kind)) => Some((self, ambig_binding, ambig_kind)),
+            Some(ambig_binding) => Some((self, ambig_binding)),
             None => match self.kind {
                 NameBindingKind::Import { binding, .. } => binding.descent_to_ambiguity(),
                 _ => None,
@@ -2064,9 +2064,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         used: Used,
         warn_ambiguity: bool,
     ) {
-        if let Some((b2, kind)) = used_binding.ambiguity {
+        if let Some(b2) = used_binding.ambiguity {
             let ambiguity_error = AmbiguityError {
-                kind,
+                kind: AmbiguityKind::GlobVsGlob,
                 ident,
                 b1: used_binding,
                 b2,