Auto merge of #155678 - aerooneqq:single-owners-query-exp, r=<try>

experiment: single owner query

Author: bors

compiler/rustc_hir/src/hir.rs

@@ -1550,7 +1550,7 @@ impl Attribute {
 }
 
 /// Attributes owned by a HIR owner.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct AttributeMap<'tcx> {
     pub map: SortedMap<ItemLocalId, &'tcx [Attribute]>,
     /// Preprocessed `#[define_opaque]` attribute.

compiler/rustc_incremental/src/assert_dep_graph.rs

@@ -113,11 +113,7 @@ impl<'tcx> IfThisChanged<'tcx> {
         for attr in attrs {
             if let Attribute::Parsed(AttributeKind::RustcIfThisChanged(span, dep_node)) = *attr {
                 let dep_node = match dep_node {
-                    None => DepNode::from_def_path_hash(
-                        self.tcx,
-                        def_path_hash,
-                        DepKind::opt_hir_owner_nodes,
-                    ),
+                    None => DepNode::from_def_path_hash(self.tcx, def_path_hash, DepKind::owner),
                     Some(n) => {
                         match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) {
                             Ok(n) => n,

compiler/rustc_incremental/src/persist/clean.rs

@@ -55,7 +55,7 @@ const BASE_FN: &[&str] = &[
 /// DepNodes for Hir, which is pretty much everything
 const BASE_HIR: &[&str] = &[
     // opt_hir_owner_nodes should be computed for all nodes
-    label_strs::opt_hir_owner_nodes,
+    label_strs::owner,
 ];
 
 /// `impl` implementation of struct/trait

compiler/rustc_middle/src/arena.rs

@@ -119,6 +119,7 @@ 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>,
         ]);
     )
 }

compiler/rustc_middle/src/hir/map.rs

@@ -12,14 +12,15 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_hir::intravisit::Visitor;
+use rustc_hir::lints::DelayedLints;
 use rustc_hir::*;
 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::{ModuleItems, nested_filter};
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
-use crate::query::LocalCrate;
+use crate::query::{IntoQueryKey, LocalCrate};
 use crate::ty::TyCtxt;
 
 /// An iterator that walks up the ancestor tree of a given `HirId`.
@@ -101,6 +102,34 @@ impl<'tcx> Iterator for ParentOwnerIterator<'tcx> {
 }
 
 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),
+        }
+    }
+
+    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)
+    }
+
+    pub fn hir_attr_map(self, id: OwnerId) -> &'tcx AttributeMap<'tcx> {
+        self.owner(id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
+    }
+
+    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)
+    }
+
+    pub fn opt_hir_owner_nodes(self, def_id: LocalDefId) -> Option<&'tcx OwnerNodes<'tcx>> {
+        self.owner(def_id).as_owner().map(|i| &i.nodes)
+    }
+
     #[inline]
     fn expect_hir_owner_nodes(self, def_id: LocalDefId) -> &'tcx OwnerNodes<'tcx> {
         self.opt_hir_owner_nodes(def_id)

compiler/rustc_middle/src/hir/mod.rs

@@ -62,27 +62,6 @@ 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(&self, tcx: TyCtxt<'hir>, def_id: LocalDefId) -> 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<'_> {
@@ -431,8 +410,7 @@ impl<'tcx> TyCtxt<'tcx> {
             HirId {
                 owner: parent_owner_id,
                 local_id: self
-                    .hir_crate(())
-                    .owner(self, parent_owner_id.def_id)
+                    .owner(parent_owner_id.def_id)
                     .unwrap()
                     .parenting
                     .get(&owner_id.def_id)
@@ -465,19 +443,28 @@ 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.local_def_id_to_hir_id = |tcx, def_id| match tcx.hir_crate(()).owner(tcx, def_id) {
-        MaybeOwner::Owner(_) => HirId::make_owner(def_id),
-        MaybeOwner::NonOwner(hir_id) => hir_id,
-        MaybeOwner::Phantom => bug!("No HirId for {:?}", def_id),
+    // 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;
+        }
+
+        if krate.delayed_ids.contains(&def_id) {
+            tcx.ensure_done().lower_delayed_owner(def_id);
+        }
+
+        tcx.delayed_owner(def_id)
     };
-    providers.opt_hir_owner_nodes =
-        |tcx, id| tcx.hir_crate(()).owner(tcx, id).as_owner().map(|i| &i.nodes);
     providers.hir_owner_parent_q = |tcx, owner_id| tcx.hir_owner_parent_impl(owner_id);
-    providers.hir_attr_map = |tcx, id| {
-        tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
-    };
-    providers.opt_ast_lowering_delayed_lints =
-        |tcx, id| tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map(|o| &o.delayed_lints);
     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| {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
@@ -517,7 +504,4 @@ pub fn provide(providers: &mut Providers) {
         |tcx, trait_id| tcx.resolutions(()).trait_impls.get(&trait_id).map_or(&[], |xs| &xs[..]);
     providers.expn_that_defined =
         |tcx, id| tcx.resolutions(()).expn_that_defined.get(&id).copied().unwrap_or(ExpnId::root());
-    providers.in_scope_traits_map = |tcx, id| {
-        tcx.hir_crate(()).owner(tcx, id.def_id).as_owner().map(|owner_info| &owner_info.trait_map)
-    };
 }

compiler/rustc_middle/src/queries.rs

@@ -68,7 +68,7 @@ use rustc_hir::def_id::{
     CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
 };
 use rustc_hir::lang_items::{LangItem, LanguageItems};
-use rustc_hir::{ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
+use rustc_hir::{ItemLocalId, PreciseCapturingArgKind};
 use rustc_index::IndexVec;
 use rustc_lint_defs::LintId;
 use rustc_macros::rustc_queries;
@@ -216,6 +216,11 @@ rustc_queries! {
         desc { "lowering the delayed AST owner `{}`", tcx.def_path_str(def_id) }
     }
 
+    query owner(def_id: LocalDefId) -> hir::MaybeOwner<'tcx> {
+        desc { "getting owner for `{}`", tcx.def_path_str(def_id) }
+        feedable
+    }
+
     query delayed_owner(def_id: LocalDefId) -> hir::MaybeOwner<'tcx>  {
         feedable
         desc { "getting child of lowered delayed AST owner `{}`", tcx.def_path_str(def_id) }
@@ -238,12 +243,6 @@ rustc_queries! {
         cache_on_disk
     }
 
-    /// Returns HIR ID for the given `LocalDefId`.
-    query local_def_id_to_hir_id(key: LocalDefId) -> hir::HirId {
-        desc { "getting HIR ID of `{}`", tcx.def_path_str(key) }
-        feedable
-    }
-
     /// Gives access to the HIR node's parent for the HIR owner `key`.
     ///
     /// This can be conveniently accessed by `tcx.hir_*` methods.
@@ -252,36 +251,6 @@ rustc_queries! {
         desc { "getting HIR parent of `{}`", tcx.def_path_str(key) }
     }
 
-    /// Gives access to the HIR nodes and bodies inside `key` if it's a HIR owner.
-    ///
-    /// This can be conveniently accessed by `tcx.hir_*` methods.
-    /// Avoid calling this query directly.
-    query opt_hir_owner_nodes(key: LocalDefId) -> Option<&'tcx hir::OwnerNodes<'tcx>> {
-        desc { "getting HIR owner items in `{}`", tcx.def_path_str(key) }
-        feedable
-    }
-
-    /// Gives access to the HIR attributes inside the HIR owner `key`.
-    ///
-    /// This can be conveniently accessed by `tcx.hir_*` methods.
-    /// Avoid calling this query directly.
-    query hir_attr_map(key: hir::OwnerId) -> &'tcx hir::AttributeMap<'tcx> {
-        desc { "getting HIR owner attributes in `{}`", tcx.def_path_str(key) }
-        feedable
-    }
-
-    /// Gives access to lints emitted during ast lowering.
-    ///
-    /// This can be conveniently accessed by `tcx.hir_*` methods.
-    /// Avoid calling this query directly.
-    query opt_ast_lowering_delayed_lints(key: hir::OwnerId) -> Option<&'tcx hir::lints::DelayedLints> {
-        desc { "getting AST lowering delayed lints in `{}`", tcx.def_path_str(key) }
-        // This query has to be `no_hash` and `eval_always`,
-        // because it accesses `delayed_lints` which is not hashed as part of the HIR
-        no_hash
-        eval_always
-    }
-
     /// Returns the *default* of the const pararameter given by `DefId`.
     ///
     /// E.g., given `struct Ty<const N: usize = 3>;` this returns `3` for `N`.
@@ -1884,10 +1853,6 @@ rustc_queries! {
     query specializes(_: (DefId, DefId)) -> bool {
         desc { "computing whether impls specialize one another" }
     }
-    query in_scope_traits_map(_: hir::OwnerId)
-        -> Option<&'tcx ItemLocalMap<&'tcx [TraitCandidate<'tcx>]>> {
-        desc { "getting traits in scope at a block" }
-    }
 
     /// Returns whether the impl or associated function has the `default` keyword.
     /// Note: This will ICE on inherent impl items. Consider using `AssocItem::defaultness`.

compiler/rustc_middle/src/ty/context.rs

@@ -36,7 +36,9 @@ 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, TraitCandidate, find_attr};
+use rustc_hir::{
+    self as hir, CRATE_HIR_ID, HirId, MaybeOwner, Node, OwnerInfo, TraitCandidate, find_attr,
+};
 use rustc_index::IndexVec;
 use rustc_macros::Diagnostic;
 use rustc_session::Session;
@@ -759,24 +761,28 @@ impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
 
     // Fills in all the important parts needed by HIR queries
     pub fn feed_hir(&self) {
-        self.local_def_id_to_hir_id(HirId::make_owner(self.def_id()));
-
         let node = hir::OwnerNode::Synthetic;
         let bodies = Default::default();
-        let attrs = hir::AttributeMap::EMPTY;
+        let attrs = hir::AttributeMap::EMPTY.clone();
 
         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.opt_hir_owner_nodes(Some(self.tcx.arena.alloc(hir::OwnerNodes {
-            opt_hash_including_bodies,
-            nodes: IndexVec::from_elem_n(
-                hir::ParentedNode { parent: hir::ItemLocalId::INVALID, node },
-                1,
-            ),
-            bodies,
+
+        self.owner(hir::MaybeOwner::Owner(self.tcx.arena.alloc(OwnerInfo {
+            attrs,
+            nodes: 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(),
         })));
-        self.feed_owner_id().hir_attr_map(attrs);
     }
 }
 

tests/incremental/clean.rs

@@ -27,11 +27,11 @@ mod y {
     use x;
 
     #[rustc_clean(
-        except="opt_hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig",
+        except="owner,generics_of,predicates_of,type_of,fn_sig",
         cfg="bfail2",
     )]
     pub fn y() {
-        //[bfail2]~^ ERROR `opt_hir_owner_nodes(y)` should be dirty but is not
+        //[bfail2]~^ ERROR `owner(y)` should be dirty but is not
         //[bfail2]~| ERROR `generics_of(y)` should be dirty but is not
         //[bfail2]~| ERROR `predicates_of(y)` should be dirty but is not
         //[bfail2]~| ERROR `type_of(y)` should be dirty but is not

tests/incremental/hash-module-order.rs

@@ -13,14 +13,14 @@
 #![feature(rustc_attrs)]
 
 #[cfg(rpass1)]
-#[rustc_clean(cfg="rpass1",except="opt_hir_owner_nodes")]
+#[rustc_clean(cfg="rpass1",except="owner")]
 mod foo {
     struct First;
     struct Second;
 }
 
 #[cfg(rpass2)]
-#[rustc_clean(cfg="rpass2",except="opt_hir_owner_nodes")]
+#[rustc_clean(cfg="rpass2",except="owner")]
 mod foo {
     struct Second;
     struct First;