Rollup merge of rust-lang#161332 - nnethercote:GlobalCtxt-Session-cleanups, r=Zalathar

Some `GlobalCtxt`/`Session` cleanups

Details in individual commits.

r? @Zalathar

Author: JonathanBrouwer

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -46,7 +46,7 @@ impl<'tcx> InferCtxt<'tcx> {
         V: TypeFoldable<TyCtxt<'tcx>>,
     {
         let ty::ParamEnvAnd { param_env, value } = value;
-        let canonical_param_env = self.tcx.canonical_param_env_cache.get_or_insert(
+        let canonical_param_env = self.tcx.caches.canonical_param_env_cache.get_or_insert(
             self.tcx,
             param_env,
             query_state,

compiler/rustc_infer/src/infer/canonical/instantiate.rs

@@ -143,17 +143,18 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
         // is both expensive (depending on the size of the clauses) and a pure function.
         let index = *self
             .tcx
+            .caches
             .highest_var_in_clauses_cache
             .lock()
             .entry(c)
             .or_insert_with(|| highest_var_in_clauses(c));
         let c_args = &self.var_values[..=index];
 
-        if let Some(c) = self.tcx.clauses_cache.lock().get(&(c, c_args)) {
+        if let Some(c) = self.tcx.caches.clauses_cache.lock().get(&(c, c_args)) {
             c
         } else {
             let folded = c.super_fold_with(self);
-            self.tcx.clauses_cache.lock().insert((c, c_args), folded);
+            self.tcx.caches.clauses_cache.lock().insert((c, c_args), folded);
             folded
         }
     }

compiler/rustc_interface/src/callbacks.rs

@@ -12,7 +12,7 @@
 use std::fmt;
 
 use rustc_errors::DiagInner;
-use rustc_middle::dep_graph::{DepNodeIndex, QuerySideEffect, TaskDepsRef};
+use rustc_middle::dep_graph::{QuerySideEffect, TaskDepsRef};
 use rustc_middle::ty::tls;
 use rustc_span::Symbol;
 
@@ -59,13 +59,13 @@ fn track_feature(feature: Symbol) {
         };
         let tcx = icx.tcx;
 
-        if let Some(dep_node_index) = tcx.sess.used_features.lock().get(&feature).copied() {
-            tcx.dep_graph.read_index(DepNodeIndex::from_u32(dep_node_index));
+        if let Some(dep_node_index) = tcx.query_system.used_features.lock().get(&feature).copied() {
+            tcx.dep_graph.read_index(dep_node_index);
         } else {
             let dep_node_index = tcx
                 .dep_graph
                 .encode_side_effect(tcx, QuerySideEffect::CheckFeature { symbol: feature });
-            tcx.sess.used_features.lock().insert(feature, dep_node_index.as_u32());
+            tcx.query_system.used_features.lock().insert(feature, dep_node_index);
             tcx.dep_graph.read_index(dep_node_index);
         }
     })

compiler/rustc_interface/src/passes.rs

@@ -1011,8 +1011,8 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
         untracked,
         incr_comp_session.as_ref(),
         dep_graph,
-        rustc_query_impl::make_dep_kind_vtables(&arena),
         rustc_query_impl::query_system(
+            &arena,
             providers.queries,
             providers.extern_queries,
             query_result_on_disk_cache,

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -411,12 +411,12 @@ impl<'a, 'tcx> TyDecoder<'tcx> for MetadataDecodeContext<'a, 'tcx> {
 
         let key = ty::CReaderCacheKey { cnum: Some(self.cdata.cnum), pos: shorthand };
 
-        if let Some(&ty) = tcx.ty_rcache.borrow().get(&key) {
+        if let Some(&ty) = tcx.caches.ty_rcache.borrow().get(&key) {
             return ty;
         }
 
         let ty = or_insert_with(self);
-        tcx.ty_rcache.borrow_mut().insert(key, ty);
+        tcx.caches.ty_rcache.borrow_mut().insert(key, ty);
         ty
     }
 

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -48,7 +48,7 @@ pub enum QuerySideEffect {
     /// effect dep node as a dependency.
     Diagnostic(DiagInner),
     /// Records the feature used during query execution.
-    /// This feature will be inserted into `sess.used_features`
+    /// This feature will be inserted into `query_system.used_features`
     /// if we mark the query as green, as that query will have
     /// the side effect dep node as a dependency.
     CheckFeature { symbol: Symbol },
@@ -779,7 +779,7 @@ impl DepGraphData {
                     tcx.dcx().emit_diagnostic(diagnostic.clone());
                 }
                 QuerySideEffect::CheckFeature { symbol } => {
-                    tcx.sess.used_features.lock().insert(*symbol, dep_node_index.as_u32());
+                    tcx.query_system.used_features.lock().insert(*symbol, dep_node_index);
                 }
             }
 

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -80,7 +80,7 @@ where
 impl<'tcx> TyCtxt<'tcx> {
     #[inline]
     pub fn dep_kind_vtable(self, dk: DepKind) -> &'tcx DepKindVTable<'tcx> {
-        &self.dep_kind_vtables[dk.as_usize()]
+        &self.query_system.dep_kind_vtables[dk.as_usize()]
     }
 
     #[inline(always)]

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -497,13 +497,13 @@ impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> {
 
         let cache_key = ty::CReaderCacheKey { cnum: None, pos: shorthand };
 
-        if let Some(&ty) = tcx.ty_rcache.borrow().get(&cache_key) {
+        if let Some(&ty) = tcx.caches.ty_rcache.borrow().get(&cache_key) {
             return ty;
         }
 
         let ty = or_insert_with(self);
         // This may overwrite the entry, but it should overwrite with the same value.
-        tcx.ty_rcache.borrow_mut().insert_same(cache_key, ty);
+        tcx.caches.ty_rcache.borrow_mut().insert_same(cache_key, ty);
         ty
     }
 

compiler/rustc_middle/src/query/plumbing.rs

@@ -2,15 +2,17 @@ use std::fmt;
 use std::ops::Deref;
 
 use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::hash_table::HashTable;
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::sync::{AtomicU64, Lock, WorkerLocal};
 use rustc_errors::Diag;
 use rustc_hir::def_id::LocalDefId;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
-use crate::dep_graph::{DepKind, DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
+use crate::dep_graph::{
+    DepKind, DepKindVTable, DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex,
+};
 use crate::ich::StableHashState;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables, TaggedQueryKey};
 use crate::query::on_disk_cache::OnDiskCache;
@@ -144,6 +146,7 @@ impl<'tcx, C: QueryCache> fmt::Debug for QueryVTable<'tcx, C> {
 
 pub struct QuerySystem<'tcx> {
     pub arenas: WorkerLocal<QueryArenas<'tcx>>,
+    pub dep_kind_vtables: &'tcx [DepKindVTable<'tcx>],
     pub query_vtables: QueryVTables<'tcx>,
 
     /// Side-effect associated with each [`DepKind::SideEffect`] node in the
@@ -153,6 +156,11 @@ pub struct QuerySystem<'tcx> {
     /// Always empty if incremental compilation is off.
     pub side_effects: Lock<FxIndexMap<DepNodeIndex, QuerySideEffect>>,
 
+    /// Enabled features that are used in the current compilation.
+    ///
+    /// The value is the `DepNodeIndex` of the node that encodes the used feature.
+    pub used_features: Lock<FxHashMap<Symbol, DepNodeIndex>>,
+
     /// This provides access to the incremental compilation on-disk cache for query results.
     /// Do not access this directly. It is only meant to be used by
     /// `DepGraph::try_mark_green()` and the query infrastructure.

compiler/rustc_middle/src/ty/context.rs

@@ -49,7 +49,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::dep_graph::{DepGraph, DepNodeIndex};
 use crate::hir::{ProjectedMaybeOwner, ProjectedOwnerInfo};
 use crate::ich::StableHashState;
 use crate::infer::canonical::{CanonicalParamEnvCache, CanonicalVarKind};
@@ -654,6 +654,38 @@ impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
     }
 }
 
+/// An assortment of global caches used by various parts of the compiler.
+///
+/// The individual fields are mostly unrelated to each other, but have been grouped together to
+/// reduce the number of top-level fields in [`GlobalCtxt`].
+#[derive(Default)]
+pub struct GlobalCaches<'tcx> {
+    // Internal caches for metadata decoding. No need to track deps on this.
+    pub ty_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
+
+    /// Caches the results of trait selection. This cache is used
+    /// for things that do not have to do with the parameters in scope.
+    pub selection_cache: traits::SelectionCache<'tcx, ty::TypingEnv<'tcx>>,
+
+    /// Caches the results of trait evaluation. This cache is used
+    /// for things that do not have to do with the parameters in scope.
+    /// Merge this with `selection_cache`?
+    pub evaluation_cache: traits::EvaluationCache<'tcx, ty::TypingEnv<'tcx>>,
+
+    /// Caches the results of goal evaluation in the new solver.
+    new_solver_evaluation_cache: Lock<search_graph::GlobalCache<TyCtxt<'tcx>>>,
+    new_solver_canonical_param_env_cache: Lock<ty::CanonicalParamEnvCache<TyCtxt<'tcx>>>,
+
+    pub canonical_param_env_cache: CanonicalParamEnvCache<'tcx>,
+
+    /// Caches the index of the highest bound var in clauses in a canonical binder.
+    pub highest_var_in_clauses_cache: Lock<FxHashMap<ty::Clauses<'tcx>, usize>>,
+
+    /// Caches the instantiation of a canonical binder given a set of args.
+    pub clauses_cache:
+        Lock<FxHashMap<(ty::Clauses<'tcx>, &'tcx [ty::GenericArg<'tcx>]), ty::Clauses<'tcx>>>,
+}
+
 /// The central data structure of the compiler. It stores references
 /// to the various **arenas** and also houses the results of the
 /// various **compiler queries** that have been performed. See the
@@ -715,6 +747,8 @@ pub struct GlobalCtxt<'tcx> {
     pub incr_comp_session: Option<&'tcx IncrCompSession>,
     pub dep_graph: DepGraph,
 
+    /// This duplicates `Session::prof` because this field is hot enough that accessing it via
+    /// `self.sess.prof` is a measurable slowdown (see #161332).
     pub prof: SelfProfilerRef,
 
     /// Common types, pre-interned for your convenience.
@@ -733,31 +767,8 @@ pub struct GlobalCtxt<'tcx> {
     untracked: Untracked,
 
     pub query_system: QuerySystem<'tcx>,
-    pub(crate) dep_kind_vtables: &'tcx [DepKindVTable<'tcx>],
-
-    // Internal caches for metadata decoding. No need to track deps on this.
-    pub ty_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
-
-    /// Caches the results of trait selection. This cache is used
-    /// for things that do not have to do with the parameters in scope.
-    pub selection_cache: traits::SelectionCache<'tcx, ty::TypingEnv<'tcx>>,
 
-    /// Caches the results of trait evaluation. This cache is used
-    /// for things that do not have to do with the parameters in scope.
-    /// Merge this with `selection_cache`?
-    pub evaluation_cache: traits::EvaluationCache<'tcx, ty::TypingEnv<'tcx>>,
-
-    /// Caches the results of goal evaluation in the new solver.
-    pub new_solver_evaluation_cache: Lock<search_graph::GlobalCache<TyCtxt<'tcx>>>,
-    pub new_solver_canonical_param_env_cache: Lock<ty::CanonicalParamEnvCache<TyCtxt<'tcx>>>,
-
-    pub canonical_param_env_cache: CanonicalParamEnvCache<'tcx>,
-
-    /// Caches the index of the highest bound var in clauses in a canonical binder.
-    pub highest_var_in_clauses_cache: Lock<FxHashMap<ty::Clauses<'tcx>, usize>>,
-    /// Caches the instantiation of a canonical binder given a set of args.
-    pub clauses_cache:
-        Lock<FxHashMap<(ty::Clauses<'tcx>, &'tcx [ty::GenericArg<'tcx>]), ty::Clauses<'tcx>>>,
+    pub caches: GlobalCaches<'tcx>,
 
     /// Data layout specification for the current target.
     pub data_layout: TargetDataLayout,
@@ -937,7 +948,6 @@ impl<'tcx> TyCtxt<'tcx> {
         untracked: Untracked,
         incr_comp_session: Option<&'tcx IncrCompSession>,
         dep_graph: DepGraph,
-        dep_kind_vtables: &'tcx [DepKindVTable<'tcx>],
         query_system: QuerySystem<'tcx>,
         hooks: crate::hooks::Providers,
         current_gcx: CurrentGcx,
@@ -967,15 +977,7 @@ impl<'tcx> TyCtxt<'tcx> {
             consts: common_consts,
             untracked,
             query_system,
-            dep_kind_vtables,
-            ty_rcache: Default::default(),
-            selection_cache: Default::default(),
-            evaluation_cache: Default::default(),
-            new_solver_evaluation_cache: Default::default(),
-            new_solver_canonical_param_env_cache: Default::default(),
-            canonical_param_env_cache: Default::default(),
-            highest_var_in_clauses_cache: Default::default(),
-            clauses_cache: Default::default(),
+            caches: Default::default(),
             data_layout,
             alloc_map: interpret::AllocMap::new(),
             current_gcx,
@@ -1612,7 +1614,7 @@ impl<'tcx> TyCtxt<'tcx> {
         }
 
         // Collect first to avoid holding the lock while linting.
-        let used_features = self.sess.used_features.lock();
+        let used_features = self.query_system.used_features.lock();
         let unused_features = self
             .features()
             .enabled_features_iter_stable_order()