Obtain ident in print without forcing delayed lowering

Author: aerooneqq

compiler/rustc_ast_lowering/src/lib.rs

@@ -54,8 +54,8 @@ use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatorState};
 use rustc_hir::lints::{AttributeLint, DelayedLint};
 use rustc_hir::{
-    self as hir, AngleBrackets, ConstArg, GenericArg, HirId, ItemLocalMap, LifetimeSource,
-    LifetimeSyntax, ParamName, Target, TraitCandidate, find_attr,
+    self as hir, AngleBrackets, ConstArg, DelayedOwner, GenericArg, HirId, ItemLocalMap,
+    LifetimeSource, LifetimeSyntax, ParamName, Target, TraitCandidate, find_attr,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
@@ -634,25 +634,31 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> mid_hir::Crate<'_> {
     let mut delayed_ids: FxIndexSet<LocalDefId> = Default::default();
 
     for def_id in ast_index.indices() {
-        let kind = match &ast_index[def_id] {
-            AstOwner::Item(Item { kind: ItemKind::Delegation { .. }, .. }) => {
-                Some(hir::DelayedOwnerKind::Item)
-            }
-            AstOwner::AssocItem(Item { kind: AssocItemKind::Delegation { .. }, .. }, ctx) => {
-                match ctx {
-                    AssocCtxt::Trait => Some(hir::DelayedOwnerKind::TraitItem),
-                    AssocCtxt::Impl { .. } => Some(hir::DelayedOwnerKind::ImplItem),
-                }
+        let delayed_owner = match &ast_index[def_id] {
+            AstOwner::Item(Item {
+                kind: ItemKind::Delegation(box Delegation { ident, .. }),
+                ..
+            }) => Some(DelayedOwner { kind: hir::DelayedOwnerKind::Item, ident: Some(*ident) }),
+            AstOwner::AssocItem(
+                Item { kind: AssocItemKind::Delegation(box Delegation { ident, .. }), .. },
+                ctx,
+            ) => {
+                let kind = match ctx {
+                    AssocCtxt::Trait => hir::DelayedOwnerKind::TraitItem,
+                    AssocCtxt::Impl { .. } => hir::DelayedOwnerKind::ImplItem,
+                };
+
+                Some(DelayedOwner { kind, ident: Some(*ident) })
             }
             _ => None,
         };
 
-        if let Some(kind) = kind {
+        if let Some(delayed_owner) = delayed_owner {
             delayed_ids.insert(def_id);
 
             let owner = lowerer.owners.get_or_insert_mut(def_id);
             if let hir::MaybeOwner::Phantom = owner {
-                *owner = hir::MaybeOwner::Delayed(kind)
+                *owner = hir::MaybeOwner::Delayed(delayed_owner)
             }
         } else {
             lowerer.lower_node(def_id);

compiler/rustc_hir/src/hir.rs

@@ -1648,11 +1648,17 @@ pub enum DelayedOwnerKind {
     TraitItem,
 }
 
+#[derive(Copy, Clone, Debug, HashStable_Generic)]
+pub struct DelayedOwner {
+    pub ident: Option<Ident>,
+    pub kind: DelayedOwnerKind,
+}
+
 #[derive(Copy, Clone, Debug, HashStable_Generic)]
 pub enum MaybeOwner<'tcx> {
     Owner(&'tcx OwnerInfo<'tcx>),
     NonOwner(HirId),
-    Delayed(DelayedOwnerKind),
+    Delayed(DelayedOwner),
     /// Used as a placeholder for unused LocalDefId.
     Phantom,
 }
@@ -1666,10 +1672,10 @@ impl<'tcx> MaybeOwner<'tcx> {
     }
 
     pub fn unwrap(self) -> &'tcx OwnerInfo<'tcx> {
-        self.as_owner().unwrap_or_else(|| panic!("Not a HIR owner"))
+        self.as_owner().unwrap_or_else(|| panic!("not a HIR owner"))
     }
 
-    pub fn expect_delayed(&self) -> DelayedOwnerKind {
+    pub fn expect_delayed(&self) -> DelayedOwner {
         if let MaybeOwner::Delayed(kind) = self { *kind } else { panic!("not a delayed owner") }
     }
 }

compiler/rustc_middle/src/hir/map.rs

@@ -835,18 +835,8 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     #[inline]
-    fn hir_opt_ident(self, id: HirId) -> Option<Ident> {
-        match self.hir_node(id) {
-            Node::Pat(&Pat { kind: PatKind::Binding(_, _, ident, _), .. }) => Some(ident),
-            // A `Ctor` doesn't have an identifier itself, but its parent
-            // struct/variant does. Compare with `hir::Map::span`.
-            Node::Ctor(..) => match self.parent_hir_node(id) {
-                Node::Item(item) => Some(item.kind.ident().unwrap()),
-                Node::Variant(variant) => Some(variant.ident),
-                _ => unreachable!(),
-            },
-            node => node.ident(),
-        }
+    pub fn hir_opt_ident(self, id: HirId) -> Option<Ident> {
+        self.hir_crate(()).opt_ident(self, id)
     }
 
     #[inline]

compiler/rustc_middle/src/hir/mod.rs

@@ -21,7 +21,7 @@ use rustc_hir::lints::DelayedLint;
 use rustc_hir::*;
 use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, HashStable};
-use rustc_span::{ErrorGuaranteed, ExpnId, Span};
+use rustc_span::{ErrorGuaranteed, ExpnId, Ident, Span};
 
 use crate::query::Providers;
 use crate::ty::{ResolverAstLowering, TyCtxt};
@@ -78,7 +78,26 @@ impl<'hir> Crate<'hir> {
     }
 
     pub fn delayed_owners_kinds(&self) -> impl Iterator<Item = (LocalDefId, DelayedOwnerKind)> {
-        self.delayed_ids.iter().copied().map(|id| (id, self.owners[id].expect_delayed()))
+        self.delayed_ids.iter().copied().map(|id| (id, self.owners[id].expect_delayed().kind))
+    }
+
+    pub fn opt_ident(&self, tcx: TyCtxt<'hir>, id: HirId) -> Option<Ident> {
+        // If possible don't force lowering of delayed owner, as it can lead to cycles.
+        if let MaybeOwner::Delayed(delayed_owner) = self.owners[id.owner.def_id] {
+            return delayed_owner.ident;
+        }
+
+        match tcx.hir_node(id) {
+            Node::Pat(&Pat { kind: PatKind::Binding(_, _, ident, _), .. }) => Some(ident),
+            // A `Ctor` doesn't have an identifier itself, but its parent
+            // struct/variant does. Compare with `hir::Map::span`.
+            Node::Ctor(..) => match tcx.parent_hir_node(id) {
+                Node::Item(item) => Some(item.kind.ident().unwrap()),
+                Node::Variant(variant) => Some(variant.ident),
+                _ => unreachable!(),
+            },
+            node => node.ident(),
+        }
     }
 }
 

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -8,12 +8,11 @@ use rustc_apfloat::Float;
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_data_structures::fx::{FxIndexMap, IndexEntry};
 use rustc_data_structures::unord::UnordMap;
-use rustc_hir as hir;
-use rustc_hir::LangItem;
 use rustc_hir::def::{self, CtorKind, DefKind, Namespace};
 use rustc_hir::def_id::{DefIdMap, DefIdSet, LOCAL_CRATE, ModDefId};
 use rustc_hir::definitions::{DefKey, DefPathDataName};
 use rustc_hir::limit::Limit;
+use rustc_hir::{self as hir, HirId, LangItem};
 use rustc_macros::{Lift, extension};
 use rustc_session::cstore::{ExternCrate, ExternCrateSource};
 use rustc_span::{Ident, RemapPathScopeComponents, Symbol, kw, sym};
@@ -3395,10 +3394,10 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
             continue;
         }
 
-        let item = tcx.hir_item(id);
-        let Some(ident) = item.kind.ident() else { continue };
+        let def_id = id.owner_id.def_id;
+        let Some(ident) = tcx.hir_opt_ident(HirId::make_owner(def_id)) else { continue };
 
-        let def_id = item.owner_id.to_def_id();
+        let def_id = def_id.to_def_id();
         let ns = tcx.def_kind(def_id).ns().unwrap_or(Namespace::TypeNS);
         collect_fn(&ident, ns, def_id);
     }