Remove attributes from projected owners, fix tests

Author: aerooneqq

compiler/rustc_middle/src/arena.rs

@@ -119,7 +119,11 @@ macro_rules! arena_types {
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
             [decode] token_stream: rustc_ast::tokenstream::TokenStream,
-            [] owner_info: rustc_hir::OwnerInfo<'tcx>,
+            [] maybe_owner: rustc_middle::hir::ProjectedMaybeOwner<'tcx>,
+            [] owner_info: rustc_middle::hir::ProjectedOwnerInfo<'tcx>,
+            [] parenting: rustc_hir::def_id::LocalDefIdMap<rustc_hir::ItemLocalId>,
+            [] trait_candidates: rustc_hir::ItemLocalMap<&'tcx [rustc_hir::TraitCandidate<'tcx>]>,
+            [] delayed_lints: rustc_hir::lints::DelayedLints,
         ]);
     )
 }

compiler/rustc_middle/src/hir/map.rs

@@ -18,7 +18,7 @@ use rustc_hir_pretty as pprust_hir;
 use rustc_span::def_id::StableCrateId;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, with_metavar_spans};
 
-use crate::hir::{MaybeOwner, ModuleItems, nested_filter};
+use crate::hir::{ModuleItems, ProjectedMaybeOwner, nested_filter};
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
 use crate::query::{IntoQueryKey, LocalCrate};
 use crate::ty::TyCtxt;
@@ -105,25 +105,24 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn local_def_id_to_hir_id(self, def_id: impl IntoQueryKey<LocalDefId>) -> HirId {
         let def_id = def_id.into_query_key();
         match self.owner(def_id) {
-            MaybeOwner::Owner(_) => HirId::make_owner(def_id),
-            MaybeOwner::NonOwner(hir_id) => hir_id,
-            MaybeOwner::Phantom => bug!("No HirId for {:?}", def_id),
+            ProjectedMaybeOwner::Owner(_) => HirId::make_owner(def_id),
+            ProjectedMaybeOwner::NonOwner(hir_id) => *hir_id,
         }
     }
 
     pub fn opt_ast_lowering_delayed_lints(self, id: OwnerId) -> Option<&'tcx DelayedLints> {
-        self.owner(id.def_id).as_owner().map(|o| &o.delayed_lints)
+        self.owner(id.def_id).as_owner().map(|o| o.delayed_lints)
     }
 
     pub fn in_scope_traits_map(
         self,
         id: OwnerId,
     ) -> Option<&'tcx ItemLocalMap<&'tcx [TraitCandidate<'tcx>]>> {
-        self.owner(id.def_id).as_owner().map(|owner_info| &owner_info.trait_map)
+        self.owner(id.def_id).as_owner().map(|owner_info| owner_info.trait_map)
     }
 
     pub fn opt_hir_owner_nodes(self, def_id: LocalDefId) -> Option<&'tcx OwnerNodes<'tcx>> {
-        self.owner(def_id).as_owner().map(|i| &i.nodes)
+        self.owner(def_id).as_owner().map(|i| i.nodes)
     }
 
     #[inline]

compiler/rustc_middle/src/hir/mod.rs

@@ -18,6 +18,7 @@ use rustc_data_structures::sync::{DynSend, DynSync, try_par_for_each_in};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap, LocalModDefId};
 use rustc_hir::definitions::PerParentDisambiguatorState;
+use rustc_hir::lints::DelayedLints;
 use rustc_hir::*;
 use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, HashStable};
@@ -62,6 +63,27 @@ impl<'hir> Crate<'hir> {
     ) -> Crate<'hir> {
         Crate { owners, delayed_ids, delayed_resolver, opt_hir_hash }
     }
+
+    /// Serves as an entry point for getting `MaybeOwner`. As owner can either be in
+    /// `owners` of `hir_crate` or it can be delayed AST owner (i.e., delegations)
+    /// we need to firstly check in `hir_crate` and then delayed AST owners.
+    /// This method can be invoked when not all delayed AST owners are lowered.
+    pub fn owner(&'hir self, tcx: TyCtxt<'hir>, def_id: LocalDefId) -> &'hir MaybeOwner<'hir> {
+        // Delayed LocalDefId can be in `self.owners` if there exists non-delayed LocalDefId
+        // which is greater than delayed LocalDefId, we use IndexVec for owners,
+        // so we will call ensure_contains_elem which will grow it.
+        if let Some(owner) = self.owners.get(def_id)
+            && (self.delayed_ids.is_empty() || !matches!(owner, MaybeOwner::Phantom))
+        {
+            return owner;
+        }
+
+        if self.delayed_ids.contains(&def_id) {
+            tcx.ensure_done().lower_delayed_owner(def_id);
+        }
+
+        tcx.delayed_owner(def_id)
+    }
 }
 
 impl<Hcx: HashStableContext> HashStable<Hcx> for Crate<'_> {
@@ -439,33 +461,65 @@ pub struct Hashes {
     pub attrs_hash: Option<Fingerprint>,
 }
 
-pub fn provide(providers: &mut Providers) {
-    providers.hir_crate_items = map::hir_crate_items;
-    providers.crate_hash = map::crate_hash;
-    providers.hir_module_items = map::hir_module_items;
-    providers.hir_attr_map =
-        |tcx, id| tcx.owner(id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs);
-    // Serves as an entry point for getting `MaybeOwner`. As owner can either be in
-    // `owners` of `hir_crate` or it can be delayed AST owner (i.e., delegations)
-    // we need to firstly check in `hir_crate` and then delayed AST owners.
-    // This method can be invoked when not all delayed AST owners are lowered.
-    providers.owner = |tcx, def_id| {
-        // Delayed LocalDefId can be in `self.owners` if there exists non-delayed LocalDefId
-        // which is greater than delayed LocalDefId, we use IndexVec for owners,
-        // so we will call ensure_contains_elem which will grow it.
-        let krate = tcx.hir_crate(());
-        if let Some(owner) = krate.owners.get(def_id)
-            && (krate.delayed_ids.is_empty() || !matches!(owner, MaybeOwner::Phantom))
-        {
-            return *owner;
+#[derive(Debug, HashStable)]
+pub struct ProjectedOwnerInfo<'tcx> {
+    /// Contents of the HIR.
+    pub nodes: &'tcx OwnerNodes<'tcx>,
+
+    /// Map from each nested owner to its parent's local id.
+    #[stable_hasher(ignore)]
+    pub parenting: &'tcx LocalDefIdMap<ItemLocalId>,
+
+    /// Map indicating what traits are in scope for places where this
+    /// is relevant; generated by resolve.
+    pub trait_map: &'tcx ItemLocalMap<&'tcx [TraitCandidate<'tcx>]>,
+
+    #[stable_hasher(ignore)]
+    pub delayed_lints: &'tcx DelayedLints,
+}
+
+#[derive(Debug, HashStable)]
+pub enum ProjectedMaybeOwner<'tcx> {
+    Owner(ProjectedOwnerInfo<'tcx>),
+    NonOwner(HirId),
+}
+
+impl<'tcx> From<&'tcx MaybeOwner<'tcx>> for ProjectedMaybeOwner<'tcx> {
+    fn from(value: &'tcx MaybeOwner<'tcx>) -> Self {
+        match value {
+            MaybeOwner::Owner(o) => ProjectedMaybeOwner::Owner(ProjectedOwnerInfo {
+                nodes: &o.nodes,
+                parenting: &o.parenting,
+                trait_map: &o.trait_map,
+                delayed_lints: &o.delayed_lints,
+            }),
+            MaybeOwner::NonOwner(hir_id) => ProjectedMaybeOwner::NonOwner(*hir_id),
+            MaybeOwner::Phantom => panic!(),
         }
+    }
+}
 
-        if krate.delayed_ids.contains(&def_id) {
-            tcx.ensure_done().lower_delayed_owner(def_id);
+impl<'tcx> ProjectedMaybeOwner<'tcx> {
+    pub fn as_owner(&'tcx self) -> Option<&'tcx ProjectedOwnerInfo<'tcx>> {
+        match self {
+            ProjectedMaybeOwner::Owner(i) => Some(i),
+            ProjectedMaybeOwner::NonOwner(_) => None,
         }
+    }
 
-        tcx.delayed_owner(def_id)
+    pub fn unwrap(&'tcx self) -> &'tcx ProjectedOwnerInfo<'tcx> {
+        self.as_owner().unwrap_or_else(|| panic!("Not a HIR owner"))
+    }
+}
+
+pub fn provide(providers: &mut Providers) {
+    providers.hir_crate_items = map::hir_crate_items;
+    providers.crate_hash = map::crate_hash;
+    providers.hir_module_items = map::hir_module_items;
+    providers.hir_attr_map = |tcx, id| {
+        tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
     };
+    providers.owner = |tcx, def_id| ProjectedMaybeOwner::from(tcx.hir_crate(()).owner(tcx, def_id));
     providers.hir_owner_parent_q = |tcx, owner_id| tcx.hir_owner_parent_impl(owner_id);
     providers.def_span = |tcx, def_id| tcx.hir_span(tcx.local_def_id_to_hir_id(def_id));
     providers.def_ident_span = |tcx, def_id| {

compiler/rustc_middle/src/queries.rs

@@ -216,13 +216,15 @@ rustc_queries! {
         desc { "lowering the delayed AST owner `{}`", tcx.def_path_str(def_id) }
     }
 
-    query owner(def_id: LocalDefId) -> hir::MaybeOwner<'tcx> {
+    query owner(def_id: LocalDefId) -> &'tcx rustc_middle::hir::ProjectedMaybeOwner<'tcx> {
         desc { "getting owner for `{}`", tcx.def_path_str(def_id) }
+        arena_cache
         feedable
     }
 
-    query delayed_owner(def_id: LocalDefId) -> hir::MaybeOwner<'tcx>  {
+    query delayed_owner(def_id: LocalDefId) -> &'tcx hir::MaybeOwner<'tcx>  {
         feedable
+        arena_cache
         desc { "getting child of lowered delayed AST owner `{}`", tcx.def_path_str(def_id) }
     }
 

compiler/rustc_middle/src/ty/context.rs

@@ -36,9 +36,7 @@ use rustc_hir::definitions::{DefPathData, Definitions, PerParentDisambiguatorSta
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
-use rustc_hir::{
-    self as hir, CRATE_HIR_ID, HirId, MaybeOwner, Node, OwnerInfo, TraitCandidate, find_attr,
-};
+use rustc_hir::{self as hir, CRATE_HIR_ID, HirId, MaybeOwner, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
 use rustc_macros::Diagnostic;
 use rustc_session::Session;
@@ -57,6 +55,7 @@ use tracing::{debug, instrument};
 use crate::arena::Arena;
 use crate::dep_graph::dep_node::make_metadata;
 use crate::dep_graph::{DepGraph, DepKindVTable, DepNodeIndex};
+use crate::hir::{ProjectedMaybeOwner, ProjectedOwnerInfo};
 use crate::ich::StableHashingContext;
 use crate::infer::canonical::{CanonicalParamEnvCache, CanonicalVarKind};
 use crate::lint::emit_lint_base;
@@ -763,26 +762,27 @@ impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
     pub fn feed_hir(&self) {
         let node = hir::OwnerNode::Synthetic;
         let bodies = Default::default();
-        let attrs = hir::AttributeMap::EMPTY.clone();
+        let attrs = hir::AttributeMap::EMPTY;
 
         let rustc_middle::hir::Hashes { opt_hash_including_bodies, .. } =
             self.tcx.hash_owner_nodes(node, &bodies, &attrs.map, attrs.define_opaque);
         let node = node.into();
 
-        self.owner(hir::MaybeOwner::Owner(self.tcx.arena.alloc(OwnerInfo {
-            attrs,
-            nodes: hir::OwnerNodes {
+        self.owner(ProjectedMaybeOwner::Owner(ProjectedOwnerInfo {
+            nodes: self.tcx.arena.alloc(hir::OwnerNodes {
                 opt_hash_including_bodies,
                 nodes: IndexVec::from_elem_n(
                     hir::ParentedNode { parent: hir::ItemLocalId::INVALID, node },
                     1,
                 ),
                 bodies,
-            },
-            parenting: Default::default(),
-            delayed_lints: Default::default(),
-            trait_map: Default::default(),
-        })));
+            }),
+            parenting: self.tcx.arena.alloc(Default::default()),
+            delayed_lints: self.tcx.arena.alloc(Default::default()),
+            trait_map: self.tcx.arena.alloc(Default::default()),
+        }));
+
+        self.feed_owner_id().hir_attr_map(attrs);
     }
 }
 

tests/incremental/hashes/enum_defs.rs

@@ -30,7 +30,7 @@
 enum     EnumVisibility { A }
 
 #[cfg(not(any(bpass1,bpass4)))]
-#[rustc_clean(cfg="bpass2", except="owner")]
+#[rustc_clean(cfg="bpass2")]
 #[rustc_clean(cfg="bpass3")]
 #[rustc_clean(cfg="bpass5", except="owner")]
 #[rustc_clean(cfg="bpass6")]
@@ -373,9 +373,9 @@ enum EnumAddMustUse {
 }
 
 #[cfg(not(any(bpass1,bpass4)))]
-#[rustc_clean(cfg="bpass2", except="owner")]
+#[rustc_clean(cfg="bpass2")]
 #[rustc_clean(cfg="bpass3")]
-#[rustc_clean(cfg="bpass5", except="owner")]
+#[rustc_clean(cfg="bpass5")]
 #[rustc_clean(cfg="bpass6")]
 #[must_use]
 enum EnumAddMustUse {
@@ -393,9 +393,9 @@ enum EnumAddReprC {
 }
 
 #[cfg(not(any(bpass1,bpass4)))]
-#[rustc_clean(cfg="bpass2", except="type_of,owner")]
+#[rustc_clean(cfg="bpass2", except="type_of")]
 #[rustc_clean(cfg="bpass3")]
-#[rustc_clean(cfg="bpass5", except="type_of,owner")]
+#[rustc_clean(cfg="bpass5", except="type_of")]
 #[rustc_clean(cfg="bpass6")]
 #[repr(C)]
 enum EnumAddReprC {