Use default disambiguator for everything instead of delegations

Author: aerooneqq

compiler/rustc_ast_lowering/src/item.rs

@@ -8,6 +8,7 @@ use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::attrs::{AttributeKind, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
+use rustc_hir::definitions::Disambiguator;
 use rustc_hir::{
     self as hir, HirId, ImplItemImplKind, LifetimeSource, PredicateOrigin, Target, find_attr,
 };
@@ -78,9 +79,10 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> ItemLowerer<'_, 'hir, R> {
     fn with_lctx(
         &mut self,
         owner: NodeId,
+        disambiguator: &mut Disambiguator,
         f: impl FnOnce(&mut LoweringContext<'_, 'hir, R>) -> hir::OwnerNode<'hir>,
     ) {
-        let mut lctx = LoweringContext::new(self.tcx, self.resolver);
+        let mut lctx = LoweringContext::new(self.tcx, self.resolver, disambiguator);
         lctx.with_hir_id_owner(owner, |lctx| f(lctx));
 
         for (def_id, info) in lctx.children {
@@ -93,28 +95,28 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> ItemLowerer<'_, 'hir, R> {
         }
     }
 
-    pub(super) fn lower_node(&mut self, def_id: LocalDefId) {
+    pub(super) fn lower_node(&mut self, def_id: LocalDefId, disambiguator: &mut Disambiguator) {
         let owner = self.owners.get_or_insert_mut(def_id);
         if let hir::MaybeOwner::Phantom = owner {
             let node = self.ast_index[def_id];
             match node {
                 AstOwner::NonOwner => {}
                 AstOwner::Crate(c) => {
                     assert_eq!(self.resolver.local_def_id(CRATE_NODE_ID), CRATE_DEF_ID);
-                    self.with_lctx(CRATE_NODE_ID, |lctx| {
+                    self.with_lctx(CRATE_NODE_ID, disambiguator, |lctx| {
                         let module = lctx.lower_mod(&c.items, &c.spans);
                         // FIXME(jdonszelman): is dummy span ever a problem here?
                         lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, DUMMY_SP, Target::Crate);
                         hir::OwnerNode::Crate(module)
                     })
                 }
-                AstOwner::Item(item) => {
-                    self.with_lctx(item.id, |lctx| hir::OwnerNode::Item(lctx.lower_item(item)))
-                }
+                AstOwner::Item(item) => self.with_lctx(item.id, disambiguator, |lctx| {
+                    hir::OwnerNode::Item(lctx.lower_item(item))
+                }),
                 AstOwner::AssocItem(item, ctxt) => {
-                    self.with_lctx(item.id, |lctx| lctx.lower_assoc_item(item, ctxt))
+                    self.with_lctx(item.id, disambiguator, |lctx| lctx.lower_assoc_item(item, ctxt))
                 }
-                AstOwner::ForeignItem(item) => self.with_lctx(item.id, |lctx| {
+                AstOwner::ForeignItem(item) => self.with_lctx(item.id, disambiguator, |lctx| {
                     hir::OwnerNode::ForeignItem(lctx.lower_foreign_item(item))
                 }),
             }

compiler/rustc_ast_lowering/src/lib.rs

@@ -94,7 +94,7 @@ pub mod stability;
 struct LoweringContext<'a, 'hir, R> {
     tcx: TyCtxt<'hir>,
     resolver: &'a mut R,
-    disambiguator: PerParentDisambiguatorState,
+    disambiguator: &'a mut Disambiguator,
 
     /// Used to allocate HIR nodes.
     arena: &'hir hir::Arena<'hir>,
@@ -154,12 +154,12 @@ struct LoweringContext<'a, 'hir, R> {
 }
 
 impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
-    fn new(tcx: TyCtxt<'hir>, resolver: &'a mut R) -> Self {
+    fn new(tcx: TyCtxt<'hir>, resolver: &'a mut R, disambiguator: &'a mut Disambiguator) -> Self {
         let registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
         Self {
             tcx,
             resolver,
-            disambiguator: Default::default(),
+            disambiguator,
             arena: tcx.hir_arena,
 
             // HirId handling.
@@ -302,10 +302,6 @@ impl<'a, 'tcx> ResolverAstLoweringExt<'tcx> for ResolverDelayedAstLowering<'a, '
     fn next_node_id(&mut self) -> NodeId {
         next_node_id(&mut self.next_node_id)
     }
-
-    fn steal_or_create_disambiguator(&self, parent: LocalDefId) -> PerParentDisambiguatorState {
-        self.base.steal_or_create_disambiguator(parent)
-    }
 }
 
 fn next_node_id(current_id: &mut NodeId) -> NodeId {
@@ -408,15 +404,6 @@ impl<'tcx> ResolverAstLowering<'tcx> {
     fn next_node_id(&mut self) -> NodeId {
         next_node_id(&mut self.next_node_id)
     }
-
-    fn steal_or_create_disambiguator(&self, parent: LocalDefId) -> PerParentDisambiguatorState {
-        self.per_parent_disambiguators.get(&parent).map(|s| s.steal()).unwrap_or_else(|| {
-            PerParentDisambiguatorState::new(
-                #[cfg(debug_assertions)]
-                parent,
-            )
-        })
-    }
 }
 
 /// How relaxed bounds `?Trait` should be treated.
@@ -637,6 +624,7 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> mid_hir::Crate<'_> {
         tcx.definitions_untracked().def_index_count(),
     );
 
+    let mut disambiguator = Disambiguator::Full(resolver.disambiguator.steal());
     let mut lowerer = item::ItemLowerer {
         tcx,
         resolver: &mut resolver,
@@ -652,7 +640,7 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> mid_hir::Crate<'_> {
             | AstOwner::AssocItem(Item { kind: AssocItemKind::Delegation { .. }, .. }, _) => {
                 delayed_ids.insert(def_id);
             }
-            _ => lowerer.lower_node(def_id),
+            _ => lowerer.lower_node(def_id, &mut disambiguator),
         };
     }
 
@@ -683,14 +671,23 @@ pub fn lower_delayed_owner(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
     let mut map = Default::default();
 
+    let per_parent_disambiguators = &resolver.base.per_parent_disambiguators;
+    let disambiguator =
+        per_parent_disambiguators.get(&def_id).map(Steal::steal).unwrap_or_else(|| {
+            PerParentDisambiguatorState::new(
+                #[cfg(debug_assertions)]
+                def_id,
+            )
+        });
+
     let mut lowerer = item::ItemLowerer {
         tcx,
         resolver: &mut resolver,
         ast_index: &ast_index,
         owners: Owners::Map(&mut map),
     };
 
-    lowerer.lower_node(def_id);
+    lowerer.lower_node(def_id, &mut Disambiguator::PerParent(disambiguator));
 
     for (child_def_id, owner) in map {
         tcx.feed_delayed_owner(child_def_id, owner);
@@ -745,13 +742,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
         let def_id = self
             .tcx
             .at(span)
-            .create_def(
-                parent,
-                name,
-                def_kind,
-                None,
-                Disambiguator::PerParent(&mut self.disambiguator),
-            )
+            .create_def(parent, name, def_kind, None, &mut self.disambiguator)
             .def_id();
 
         debug!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id, node_id);
@@ -792,8 +783,6 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     ) {
         let owner_id = self.owner_id(owner);
 
-        let new_disambig = self.resolver.steal_or_create_disambiguator(owner_id.def_id);
-        let disambiguator = std::mem::replace(&mut self.disambiguator, new_disambig);
         let current_attrs = std::mem::take(&mut self.attrs);
         let current_bodies = std::mem::take(&mut self.bodies);
         let current_define_opaque = std::mem::take(&mut self.define_opaque);
@@ -828,7 +817,6 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
         assert!(self.impl_trait_bounds.is_empty());
         let info = self.make_owner_info(item);
 
-        self.disambiguator = disambiguator;
         self.attrs = current_attrs;
         self.bodies = current_bodies;
         self.define_opaque = current_define_opaque;

compiler/rustc_const_eval/src/interpret/intern.rs

@@ -105,7 +105,7 @@ fn intern_shallow<'tcx, M: CompileTimeMachine<'tcx>>(
     ecx: &mut InterpCx<'tcx, M>,
     alloc_id: AllocId,
     mutability: Mutability,
-    disambiguator: Option<&mut DisambiguatorState>,
+    disambiguator: Option<&mut Disambiguator>,
 ) -> Result<impl Iterator<Item = CtfeProvenance> + 'tcx, InternError> {
     trace!("intern_shallow {:?}", alloc_id);
     // remove allocation
@@ -144,7 +144,7 @@ fn intern_as_new_static<'tcx>(
     static_id: LocalDefId,
     alloc_id: AllocId,
     alloc: ConstAllocation<'tcx>,
-    disambiguator: &mut DisambiguatorState,
+    disambiguator: &mut Disambiguator,
 ) {
     // `intern_const_alloc_recursive` is called once per static and it contains the `DisambiguatorState`.
     //  The `<static_id>::{{nested}}` path is thus unique to `intern_const_alloc_recursive` and the
@@ -155,7 +155,7 @@ fn intern_as_new_static<'tcx>(
         None,
         DefKind::Static { safety: hir::Safety::Safe, mutability: alloc.0.mutability, nested: true },
         Some(DefPathData::NestedStatic),
-        Disambiguator::Full(disambiguator),
+        disambiguator,
     );
     tcx.set_nested_alloc_id_static(alloc_id, feed.def_id());
 
@@ -205,7 +205,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx>>(
     intern_kind: InternKind,
     ret: &MPlaceTy<'tcx>,
 ) -> Result<(), InternError> {
-    let mut disambiguator = DisambiguatorState::new();
+    let mut disambiguator = Disambiguator::Full(DisambiguatorState::new());
 
     // We are interning recursively, and for mutability we are distinguishing the "root" allocation
     // that we are starting in, and all other allocations that we are encountering recursively.

compiler/rustc_hir/src/definitions.rs

@@ -97,9 +97,25 @@ impl DefPathTable {
     }
 }
 
-pub enum Disambiguator<'a> {
-    PerParent(&'a mut PerParentDisambiguatorState),
-    Full(&'a mut DisambiguatorState),
+pub enum Disambiguator {
+    PerParent(PerParentDisambiguatorState),
+    Full(DisambiguatorState),
+}
+
+impl Disambiguator {
+    pub fn expect_full(self) -> DisambiguatorState {
+        match self {
+            Disambiguator::PerParent(_) => panic!("expected full disambiguator"),
+            Disambiguator::Full(d) => d,
+        }
+    }
+
+    pub fn expect_per_parent(self) -> PerParentDisambiguatorState {
+        match self {
+            Disambiguator::PerParent(d) => d,
+            Disambiguator::Full(_) => panic!("expected per-parent disambiguator"),
+        }
+    }
 }
 
 #[derive(Debug, Default, Clone)]
@@ -407,7 +423,7 @@ impl Definitions {
         &mut self,
         parent: LocalDefId,
         data: DefPathData,
-        disambiguator: Disambiguator<'_>,
+        disambiguator: &mut Disambiguator,
     ) -> LocalDefId {
         // We can't use `Debug` implementation for `LocalDefId` here, since it tries to acquire a
         // reference to `Definitions` and we're already holding a mutable reference.

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -64,7 +64,7 @@ impl ResolvedArg {
 struct BoundVarContext<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     rbv: &'a mut ResolveBoundVars<'tcx>,
-    disambiguator: &'a mut DisambiguatorState,
+    disambiguator: &'a mut Disambiguator,
     scope: ScopeRef<'a, 'tcx>,
     opaque_capture_errors: RefCell<Option<OpaqueHigherRankedLifetimeCaptureErrors>>,
 }
@@ -259,7 +259,7 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou
         tcx,
         rbv: &mut rbv,
         scope: &Scope::Root { opt_parent_item: None },
-        disambiguator: &mut DisambiguatorState::new(),
+        disambiguator: &mut Disambiguator::Full(DisambiguatorState::new()),
         opaque_capture_errors: RefCell::new(None),
     };
     match tcx.hir_owner_node(local_def_id) {
@@ -1523,7 +1523,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                     None,
                     DefKind::LifetimeParam,
                     Some(DefPathData::OpaqueLifetime(ident.name)),
-                    Disambiguator::Full(self.disambiguator),
+                    &mut self.disambiguator,
                 );
                 feed.def_span(ident.span);
                 feed.def_ident_span(Some(ident.span));

compiler/rustc_middle/src/ty/context.rs

@@ -1398,7 +1398,7 @@ impl<'tcx> TyCtxtAt<'tcx> {
         name: Option<Symbol>,
         def_kind: DefKind,
         override_def_path_data: Option<DefPathData>,
-        disambiguator: Disambiguator<'_>,
+        disambiguator: &mut Disambiguator,
     ) -> TyCtxtFeed<'tcx, LocalDefId> {
         let feed =
             self.tcx.create_def(parent, name, def_kind, override_def_path_data, disambiguator);
@@ -1416,7 +1416,7 @@ impl<'tcx> TyCtxt<'tcx> {
         name: Option<Symbol>,
         def_kind: DefKind,
         override_def_path_data: Option<DefPathData>,
-        disambiguator: Disambiguator<'_>,
+        disambiguator: &mut Disambiguator,
     ) -> TyCtxtFeed<'tcx, LocalDefId> {
         let data = override_def_path_data.unwrap_or_else(|| def_kind.def_path_data(name));
         // The following call has the side effect of modifying the tables inside `definitions`.

compiler/rustc_middle/src/ty/mod.rs

@@ -40,7 +40,7 @@ use rustc_hir as hir;
 use rustc_hir::attrs::StrippedCfgItem;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, DocLinkResMap, LifetimeRes, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap};
-use rustc_hir::definitions::PerParentDisambiguatorState;
+use rustc_hir::definitions::{DisambiguatorState, PerParentDisambiguatorState};
 use rustc_hir::{LangItem, attrs as attr, find_attr};
 use rustc_index::IndexVec;
 use rustc_index::bit_set::BitMatrix;
@@ -227,6 +227,7 @@ pub struct ResolverAstLowering<'tcx> {
     // Information about delegations which is used when handling recursive delegations
     pub delegation_infos: LocalDefIdMap<DelegationInfo>,
 
+    pub disambiguator: Steal<DisambiguatorState>,
     pub per_parent_disambiguators: LocalDefIdMap<Steal<PerParentDisambiguatorState>>,
 }
 

compiler/rustc_mir_transform/src/coroutine/by_move_body.rs

@@ -221,7 +221,7 @@ pub(crate) fn coroutine_by_move_body_def_id<'tcx>(
         None,
         DefKind::SyntheticCoroutineBody,
         None,
-        Disambiguator::Full(&mut DisambiguatorState::new()),
+        &mut Disambiguator::Full(DisambiguatorState::new()),
     );
     by_move_body.source =
         mir::MirSource::from_instance(InstanceKind::Item(body_def.def_id().to_def_id()));

compiler/rustc_resolve/src/def_collector.rs

@@ -33,6 +33,17 @@ struct DefCollector<'a, 'ra, 'tcx> {
     expansion: LocalExpnId,
 }
 
+struct ParentUpdate {
+    def_id: LocalDefId,
+    is_delegation: bool,
+}
+
+impl Into<ParentUpdate> for LocalDefId {
+    fn into(self) -> ParentUpdate {
+        ParentUpdate { def_id: self, is_delegation: false }
+    }
+}
+
 impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
     fn create_def(
         &mut self,
@@ -54,13 +65,21 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
                 def_kind,
                 self.expansion.to_expn_id(),
                 span.with_parent(None),
+                self.invocation_parent.is_delegation,
             )
             .def_id()
     }
 
-    fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: LocalDefId, f: F) {
-        let orig_parent_def = mem::replace(&mut self.invocation_parent.parent_def, parent_def);
+    fn with_parent<F: FnOnce(&mut Self)>(&mut self, update: impl Into<ParentUpdate>, f: F) {
+        let update = update.into();
+
+        let orig_parent_def = mem::replace(&mut self.invocation_parent.parent_def, update.def_id);
+        let orig_is_delegation =
+            mem::replace(&mut self.invocation_parent.is_delegation, update.is_delegation);
+
         f(self);
+
+        self.invocation_parent.is_delegation = orig_is_delegation;
         self.invocation_parent.parent_def = orig_parent_def;
     }
 
@@ -184,7 +203,10 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             self.resolver.new_local_macro(def_id, macro_data);
         }
 
-        self.with_parent(def_id, |this| {
+        let is_delegation = matches!(i.kind, ItemKind::Delegation(..));
+        let update = ParentUpdate { is_delegation, def_id };
+
+        self.with_parent(update, |this| {
             this.with_impl_trait(ImplTraitContext::Existential, |this| {
                 match i.kind {
                     ItemKind::Struct(_, _, ref struct_def)
@@ -370,8 +392,11 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             }
         };
 
-        let def = self.create_def(i.id, Some(ident.name), def_kind, i.span);
-        self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt));
+        let is_delegation = matches!(i.kind, AssocItemKind::Delegation(..));
+        let def_id = self.create_def(i.id, Some(ident.name), def_kind, i.span);
+        let update = ParentUpdate { is_delegation, def_id };
+
+        self.with_parent(update, |this| visit::walk_assoc_item(this, i, ctxt));
     }
 
     fn visit_pat(&mut self, pat: &'a Pat) {