Place delegations' disambiguators in Steal near DelegationInfos

Author: aerooneqq

compiler/rustc_ast_lowering/src/item.rs

@@ -79,11 +79,11 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> ItemLowerer<'_, 'hir, R> {
         if let hir::MaybeOwner::Phantom = owner {
             let node = self.ast_index[def_id];
 
-            let disambig = if let Some(info) = self.resolver.delegation_infos.get_mut(&def_id) {
+            let disambig = if let Some(disambig) = self.resolver.delegation_disambiguator(def_id) {
                 // Here we use disambiguator that we saved from resolve stage, as we generate
                 // new def_ids with names from other code, there may be situations when there
                 // will be def path hash collision (see #153410).
-                std::mem::take(&mut info.disambig)
+                disambig.steal()
             } else {
                 DisambiguatorState::new()
             };

compiler/rustc_ast_lowering/src/lib.rs

@@ -44,6 +44,7 @@ use rustc_attr_parsing::{AttributeParser, Late, OmitDoc};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::steal::Steal;
 use rustc_data_structures::sync::spawn;
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle};
@@ -315,7 +316,11 @@ impl<'tcx> ResolverAstLowering<'tcx> {
     }
 
     fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
-        self.delegation_infos.get(&id)
+        self.delegation_infos.get(&id).map(|(i, _)| i)
+    }
+
+    fn delegation_disambiguator(&self, id: LocalDefId) -> Option<&Steal<DisambiguatorState>> {
+        self.delegation_infos.get(&id).map(|(_, d)| d)
     }
 
     fn opt_local_def_id(&self, id: NodeId) -> Option<LocalDefId> {

compiler/rustc_middle/src/ty/mod.rs

@@ -224,7 +224,8 @@ pub struct ResolverAstLowering<'tcx> {
     /// Information about functions signatures for delegation items expansion
     pub delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
     // Information about delegations which is used when handling recursive delegations
-    pub delegation_infos: LocalDefIdMap<DelegationInfo>,
+    // and disambiguator associated with each delegation.
+    pub delegation_infos: LocalDefIdMap<(DelegationInfo, Steal<DisambiguatorState>)>,
 }
 
 bitflags::bitflags! {
@@ -243,16 +244,11 @@ pub struct DelegationInfo {
     // for details see https://github.com/rust-lang/rust/issues/118212#issuecomment-2160686914
     pub resolution_node: ast::NodeId,
     pub attrs: DelegationAttrs,
-    pub disambig: DisambiguatorState,
 }
 
 impl Default for DelegationInfo {
     fn default() -> DelegationInfo {
-        DelegationInfo {
-            resolution_node: DUMMY_NODE_ID,
-            attrs: Default::default(),
-            disambig: Default::default(),
-        }
+        DelegationInfo { resolution_node: DUMMY_NODE_ID, attrs: Default::default() }
     }
 }
 

compiler/rustc_resolve/src/late.rs

@@ -3819,7 +3819,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
         self.visit_path(&delegation.path);
 
-        let info = self.r.delegation_infos.entry(self.r.local_def_id(item_id)).or_default();
+        let info = &mut self.r.delegation_infos.entry(self.r.local_def_id(item_id)).or_default().0;
         info.attrs = create_delegation_attrs(attrs);
         info.resolution_node = if is_in_trait_impl { item_id } else { delegation.id };
 

compiler/rustc_resolve/src/lib.rs

@@ -1340,7 +1340,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Generic args to suggest for required params (e.g. `<'_>`, `<_, _>`), if any.
     item_required_generic_args_suggestions: FxHashMap<LocalDefId, String> = default::fx_hash_map(),
     delegation_fn_sigs: LocalDefIdMap<DelegationFnSig> = Default::default(),
-    delegation_infos: LocalDefIdMap<DelegationInfo> = Default::default(),
+    delegation_infos: LocalDefIdMap<(DelegationInfo, DisambiguatorState)> = Default::default(),
 
     main_def: Option<MainDefinition> = None,
     trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>,
@@ -1528,7 +1528,7 @@ impl<'tcx> Resolver<'_, 'tcx> {
 
         if is_delegation {
             let data = def_kind.def_path_data(name);
-            self.delegation_infos.entry(parent).or_default().disambig.next(parent, data);
+            self.delegation_infos.entry(parent).or_default().1.next(parent, data);
         }
 
         // FIXME: remove `def_span` body, pass in the right spans here and call `tcx.at().create_def()`
@@ -1867,7 +1867,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             lifetime_elision_allowed: self.lifetime_elision_allowed,
             lint_buffer: Steal::new(self.lint_buffer),
             delegation_fn_sigs: self.delegation_fn_sigs,
-            delegation_infos: self.delegation_infos,
+            delegation_infos: self
+                .delegation_infos
+                .into_items()
+                .map(|(key, (i, d))| (key, (i, Steal::new(d))))
+                .collect(),
         };
         ResolverOutputs { global_ctxt, ast_lowering }
     }