Do not recurse inside lookup_deprecation_entry query.

Author: cjgillot

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -11,7 +11,7 @@ use rustc_middle::arena::ArenaAllocatable;
 use rustc_middle::bug;
 use rustc_middle::metadata::ModChild;
 use rustc_middle::middle::exported_symbols::ExportedSymbol;
-use rustc_middle::middle::stability::DeprecationEntry;
+use rustc_middle::middle::stability::RawDeprecationEntry;
 use rustc_middle::query::{ExternProviders, LocalCrate};
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{self, TyCtxt};
@@ -103,10 +103,10 @@ impl<'a, 'tcx, T: Copy + Decodable<DecodeContext<'a, 'tcx>>>
     }
 }
 
-impl ProcessQueryValue<'_, Option<DeprecationEntry>> for Option<Deprecation> {
+impl ProcessQueryValue<'_, RawDeprecationEntry> for Option<Deprecation> {
     #[inline(always)]
-    fn process_decoded(self, _tcx: TyCtxt<'_>, _err: impl Fn() -> !) -> Option<DeprecationEntry> {
-        self.map(DeprecationEntry::external)
+    fn process_decoded(self, _tcx: TyCtxt<'_>, _err: impl Fn() -> !) -> RawDeprecationEntry {
+        RawDeprecationEntry::external(self)
     }
 }
 
@@ -268,7 +268,7 @@ provide! { tcx, def_id, other, cdata,
     lookup_stability => { table }
     lookup_const_stability => { table }
     lookup_default_body_stability => { table }
-    lookup_deprecation_entry => { table }
+    lookup_deprecation_entry_raw => { table }
     params_in_repr => { table }
     unused_generic_params => { table_direct }
     def_kind => { cdata.def_kind(def_id.index) }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1794,7 +1794,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     fn encode_deprecation(&mut self, def_id: DefId) {
         if let Some(depr) = self.tcx.lookup_deprecation(def_id) {
-            record!(self.tables.lookup_deprecation_entry[def_id] <- depr);
+            record!(self.tables.lookup_deprecation_entry_raw[def_id] <- depr);
         }
     }
 

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -418,7 +418,7 @@ define_tables! {
     lookup_stability: Table<DefIndex, LazyValue<attr::Stability>>,
     lookup_const_stability: Table<DefIndex, LazyValue<attr::ConstStability>>,
     lookup_default_body_stability: Table<DefIndex, LazyValue<attr::DefaultBodyStability>>,
-    lookup_deprecation_entry: Table<DefIndex, LazyValue<attr::Deprecation>>,
+    lookup_deprecation_entry_raw: Table<DefIndex, LazyValue<attr::Deprecation>>,
     explicit_predicates_of: Table<DefIndex, LazyValue<ty::GenericPredicates<'static>>>,
     generics_of: Table<DefIndex, LazyValue<ty::Generics>>,
     type_of: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, Ty<'static>>>>,

compiler/rustc_middle/src/middle/stability.rs

@@ -32,7 +32,13 @@ pub enum StabilityLevel {
     Stable,
 }
 
-/// An entry in the `depr_map`.
+#[derive(Copy, Clone, HashStable, Debug, Encodable, Decodable)]
+pub enum RawDeprecationEntry {
+    Explicit(DeprecationEntry),
+    Inherited,
+    None,
+}
+
 #[derive(Copy, Clone, HashStable, Debug, Encodable, Decodable)]
 pub struct DeprecationEntry {
     /// The metadata of the attribute associated with this entry.
@@ -42,16 +48,21 @@ pub struct DeprecationEntry {
     origin: Option<LocalDefId>,
 }
 
-impl DeprecationEntry {
-    pub fn local(attr: Deprecation, def_id: LocalDefId) -> DeprecationEntry {
-        DeprecationEntry { attr, origin: Some(def_id) }
+impl RawDeprecationEntry {
+    pub fn local(attr: Deprecation, def_id: LocalDefId) -> RawDeprecationEntry {
+        RawDeprecationEntry::Explicit(DeprecationEntry { attr, origin: Some(def_id) })
     }
 
-    pub fn external(attr: Deprecation) -> DeprecationEntry {
-        DeprecationEntry { attr, origin: None }
+    pub fn external(attr: Option<Deprecation>) -> RawDeprecationEntry {
+        match attr {
+            Some(attr) => RawDeprecationEntry::Explicit(DeprecationEntry { attr, origin: None }),
+            None => RawDeprecationEntry::None,
+        }
     }
+}
 
-    pub fn same_origin(&self, other: &DeprecationEntry) -> bool {
+impl DeprecationEntry {
+    fn same_origin(&self, other: &DeprecationEntry) -> bool {
         match (self.origin, other.origin) {
             (Some(o1), Some(o2)) => o1 == o2,
             _ => false,
@@ -617,7 +628,17 @@ impl<'tcx> TyCtxt<'tcx> {
         is_allowed
     }
 
+    pub fn lookup_deprecation_entry(self, mut id: DefId) -> Option<DeprecationEntry> {
+        loop {
+            match self.lookup_deprecation_entry_raw(id) {
+                RawDeprecationEntry::Explicit(depr) => return Some(depr),
+                RawDeprecationEntry::None => return None,
+                RawDeprecationEntry::Inherited => id = self.opt_parent(id)?,
+            }
+        }
+    }
+
     pub fn lookup_deprecation(self, id: DefId) -> Option<Deprecation> {
-        self.lookup_deprecation_entry(id).map(|depr| depr.attr)
+        self.lookup_deprecation_entry(id).map(|d| d.attr)
     }
 }

compiler/rustc_middle/src/query/erase.rs

@@ -244,7 +244,6 @@ trivial! {
     Option<rustc_hir::def::DefKind>,
     Option<rustc_hir::CoroutineKind>,
     Option<rustc_hir::HirId>,
-    Option<rustc_middle::middle::stability::DeprecationEntry>,
     Option<rustc_middle::ty::AsyncDestructor>,
     Option<rustc_middle::ty::Destructor>,
     Option<rustc_middle::ty::ImplTraitInTraitData>,
@@ -263,7 +262,6 @@ trivial! {
     rustc_ast::expand::allocator::AllocatorKind,
     rustc_attr::ConstStability,
     rustc_attr::DefaultBodyStability,
-    rustc_attr::Deprecation,
     rustc_attr::Stability,
     rustc_data_structures::svh::Svh,
     rustc_errors::ErrorGuaranteed,
@@ -287,7 +285,7 @@ trivial! {
     rustc_middle::middle::exported_symbols::SymbolExportInfo,
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
     rustc_middle::middle::resolve_bound_vars::ResolvedArg,
-    rustc_middle::middle::stability::DeprecationEntry,
+    rustc_middle::middle::stability::RawDeprecationEntry,
     rustc_middle::mir::ConstQualifs,
     rustc_middle::mir::interpret::AllocId,
     rustc_middle::mir::interpret::CtfeProvenance,

compiler/rustc_middle/src/query/mod.rs

@@ -54,7 +54,7 @@ use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use crate::middle::lib_features::LibFeatures;
 use crate::middle::privacy::EffectiveVisibilities;
 use crate::middle::resolve_bound_vars::{ObjectLifetimeDefault, ResolveBoundVars, ResolvedArg};
-use crate::middle::stability::{self, DeprecationEntry};
+use crate::middle::stability::{self, RawDeprecationEntry};
 use crate::mir::interpret::{
     EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
     EvalToValTreeResult, GlobalId, LitToConstError, LitToConstInput,
@@ -1223,7 +1223,7 @@ rustc_queries! {
         desc { |tcx| "computing should_inherit_track_caller of `{}`", tcx.def_path_str(def_id) }
     }
 
-    query lookup_deprecation_entry(def_id: DefId) -> Option<DeprecationEntry> {
+    query lookup_deprecation_entry_raw(def_id: DefId) -> RawDeprecationEntry {
         desc { |tcx| "checking whether `{}` is deprecated", tcx.def_path_str(def_id) }
         cache_on_disk_if { def_id.is_local() }
         separate_provide_extern

compiler/rustc_passes/src/stability.rs

@@ -19,15 +19,15 @@ use rustc_hir::{FieldDef, Item, ItemKind, TraitRef, Ty, TyKind, Variant};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::lib_features::{FeatureStability, LibFeatures};
 use rustc_middle::middle::privacy::EffectiveVisibilities;
-use rustc_middle::middle::stability::{AllowUnstable, DeprecationEntry, Index};
+use rustc_middle::middle::stability::{AllowUnstable, Index, RawDeprecationEntry};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{INEFFECTIVE_UNSTABLE_TRAIT_IMPL, USELESS_DEPRECATED};
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
 use rustc_target::spec::abi::Abi;
-use tracing::{debug, info};
+use tracing::debug;
 
 use crate::errors;
 
@@ -128,19 +128,16 @@ fn annotation_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> AnnotationKind {
     }
 }
 
-fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DeprecationEntry> {
+fn lookup_deprecation_entry_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> RawDeprecationEntry {
     let attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(def_id));
 
     let depr = attr::find_deprecation(&tcx.sess, tcx.features(), attrs);
     let Some((depr, span)) = &depr else {
-        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
-            let parent_id = tcx.opt_local_parent(def_id)?;
-            let parent_depr = tcx.lookup_deprecation_entry(parent_id)?;
-            info!("tagging child {:?} as deprecated from parent", def_id);
-            return Some(parent_depr);
-        }
-
-        return None;
+        return if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+            RawDeprecationEntry::Inherited
+        } else {
+            RawDeprecationEntry::None
+        };
     };
 
     let kind = annotation_kind(tcx, def_id);
@@ -155,7 +152,7 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
     }
 
     // `Deprecation` is just two pointers, no need to intern it
-    Some(DeprecationEntry::local(*depr, def_id))
+    RawDeprecationEntry::local(*depr, def_id)
 }
 
 /// A private tree-walker for producing an `Index`.
@@ -184,7 +181,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
     ) where
         F: FnOnce(&mut Self),
     {
-        let depr = self.tcx.lookup_deprecation_entry(def_id);
+        let depr = self.tcx.lookup_deprecation(def_id.to_def_id());
         let is_deprecated = depr.is_some();
 
         if !self.tcx.features().staged_api {
@@ -237,7 +234,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             }
         }
 
-        if stab.is_none() && depr.map_or(false, |d| d.attr.is_since_rustc_version()) {
+        if stab.is_none() && depr.map_or(false, |d| d.is_since_rustc_version()) {
             if let Some(attr) = attrs.iter().find(|attr| attr.has_name(sym::deprecated)) {
                 self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span: attr.span });
             }
@@ -263,7 +260,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             // Check if deprecated_since < stable_since. If it is,
             // this is *almost surely* an accident.
             if let Some(depr) = depr
-                && let DeprecatedSince::RustcVersion(dep_since) = depr.attr.since
+                && let DeprecatedSince::RustcVersion(dep_since) = depr.since
                 && let attr::Stable { since: stab_since, .. } = stab.level
             {
                 match stab_since {
@@ -707,7 +704,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         lookup_stability: |tcx, id| tcx.stability().local_stability(id),
         lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id),
         lookup_default_body_stability: |tcx, id| tcx.stability().local_default_body_stability(id),
-        lookup_deprecation_entry,
+        lookup_deprecation_entry_raw,
         ..*providers
     };
 }