Small improvements

Author: aerooneqq

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -55,7 +55,7 @@ pub enum QuerySideEffect {
 #[derive(Clone)]
 pub struct DepGraph {
     is_in_sandbox: Arc<AtomicBool>,
-    data: Option<Arc<DepGraphData>>,
+    data: [Option<Arc<DepGraphData>>; 2],
 
     /// This field is used for assigning DepNodeIndices when running in
     /// non-incremental mode. Even in non-incremental mode we make sure that
@@ -170,34 +170,31 @@ impl DepGraph {
         }
 
         DepGraph {
-            data: Some(Arc::new(DepGraphData {
-                previous_work_products: prev_work_products,
-                current,
-                previous: prev_graph,
-                colors,
-                debug_loaded_from_disk: Default::default(),
-            })),
+            data: [
+                Some(Arc::new(DepGraphData {
+                    previous_work_products: prev_work_products,
+                    current,
+                    previous: prev_graph,
+                    colors,
+                    debug_loaded_from_disk: Default::default(),
+                })),
+                None,
+            ],
             virtual_dep_node_index: Arc::new(AtomicU32::new(0)),
             is_in_sandbox: Default::default(),
         }
     }
 
     pub fn new_disabled() -> DepGraph {
         DepGraph {
-            data: None,
+            data: [None, None],
             virtual_dep_node_index: Arc::new(AtomicU32::new(0)),
             is_in_sandbox: Default::default(),
         }
     }
 
-    #[inline]
     pub fn data(&self) -> Option<&DepGraphData> {
-        self.data.as_deref().filter(|_| !self.is_in_sandbox())
-    }
-
-    #[inline]
-    pub fn is_in_sandbox(&self) -> bool {
-        self.is_in_sandbox.load(Ordering::Relaxed)
+        self.data[self.is_in_sandbox.load(Ordering::Relaxed) as usize].as_deref()
     }
 
     /// Returns `true` if we are actually building the full dep-graph, and `false` otherwise.

compiler/rustc_middle/src/hir/mod.rs

@@ -24,7 +24,6 @@ use rustc_macros::{Decodable, Encodable, StableHash};
 use rustc_span::{ErrorGuaranteed, ExpnId, Span};
 
 use crate::query::Providers;
-use crate::ty::print::with_no_trimmed_paths;
 use crate::ty::{ResolverAstLowering, TyCtxt};
 
 /// The top-level data structure that stores the entire contents of
@@ -208,25 +207,11 @@ impl ModuleItems {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
-    fn sandbox(self, action: impl FnOnce() -> ()) {
-        self.with_sandbox(|| {
-            self.enter_query_sandbox();
-
-            self.dep_graph.with_sandbox(|| {
-                with_no_trimmed_paths!({
-                    action();
-                });
-            });
-
-            self.leave_query_sandbox();
-        });
-    }
-
     pub fn force_delayed_owners_lowering(self) {
         let krate = self.hir_crate(());
 
         if !krate.delayed_ids.is_empty() {
-            self.sandbox(|| {
+            self.with_sandbox(|| {
                 self.ensure_done().hir_crate_items(());
                 self.ensure_done().crate_inherent_impls(());
 

compiler/rustc_middle/src/query/caches.rs

@@ -1,6 +1,5 @@
-use std::sync::Mutex;
-
 use rustc_data_structures::sharded::ShardedHashMap;
+use rustc_data_structures::sync::Lock;
 pub use rustc_data_structures::vec_cache::VecCache;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_index::Idx;
@@ -99,12 +98,12 @@ where
 /// In-memory cache for queries whose key type only has one value (e.g. `()`).
 /// The cache therefore only needs to store one query return value.
 pub struct SingleCache<V> {
-    cache: Mutex<Option<(V, DepNodeIndex)>>,
+    cache: Lock<Option<(V, DepNodeIndex)>>,
 }
 
 impl<V> Default for SingleCache<V> {
     fn default() -> Self {
-        SingleCache { cache: Mutex::new(None) }
+        SingleCache { cache: Default::default() }
     }
 }
 
@@ -117,27 +116,27 @@ where
 
     #[inline(always)]
     fn lookup(&self, _key: &()) -> Option<(V, DepNodeIndex)> {
-        self.cache.get_cloned().unwrap()
+        self.cache.lock().clone()
     }
 
     #[inline]
     fn complete(&self, _key: (), value: V, index: DepNodeIndex) {
-        self.cache.set(Some((value, index))).ok();
+        *self.cache.lock() = Some((value, index))
     }
 
     fn for_each(&self, f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex)) {
-        if let Some(value) = self.cache.get_cloned().unwrap() {
+        if let Some(value) = self.cache.lock().clone() {
             f(&(), &value.0, value.1)
         }
     }
 
     fn len(&self) -> usize {
-        self.cache.get_cloned().unwrap().is_some().into()
+        self.cache.lock().is_some().into()
     }
 
     fn invalidate(&self, selector: impl Fn(Self::Key) -> bool) {
         if selector(()) {
-            self.cache.set(None).ok();
+            *self.cache.lock() = None;
         }
     }
 }

compiler/rustc_middle/src/query/inner.rs

@@ -20,10 +20,7 @@ where
 {
     match cache.lookup(&key) {
         Some((value, index)) => {
-            if !tcx.is_in_sandbox() {
-                tcx.prof.query_cache_hit(index.into());
-            }
-
+            tcx.prof.query_cache_hit(index.into());
             tcx.dep_graph.read_index(index);
 
             Some(value)

compiler/rustc_middle/src/ty/context.rs

@@ -12,7 +12,7 @@ use std::ffi::OsStr;
 use std::hash::{Hash, Hasher};
 use std::marker::{PhantomData, PointeeSized};
 use std::ops::{Bound, Deref};
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::sync::{Arc, OnceLock};
 use std::{fmt, iter, mem};
 
@@ -67,6 +67,7 @@ use crate::thir::Thir;
 use crate::traits;
 use crate::traits::solve::{ExternalConstraints, ExternalConstraintsData, PredefinedOpaques};
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
+use crate::ty::print::with_no_trimmed_paths;
 use crate::ty::{
     self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, FnSigKind, GenericArg,
     GenericArgs, GenericArgsRef, GenericParamDefKind, List, ListWithCachedTypeInfo, ParamConst,
@@ -836,17 +837,22 @@ impl CurrentGcx {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
-    #[inline]
     pub fn is_in_sandbox(self) -> bool {
-        self.is_in_sandbox.load(std::sync::atomic::Ordering::Relaxed)
+        self.is_in_sandbox.load(AtomicOrdering::Relaxed)
     }
 
     pub fn with_sandbox(self, op: impl FnOnce()) {
-        self.is_in_sandbox.store(true, std::sync::atomic::Ordering::Relaxed);
+        self.is_in_sandbox.store(true, AtomicOrdering::Relaxed);
+        self.enter_query_sandbox();
 
-        op();
+        self.dep_graph.with_sandbox(|| {
+            with_no_trimmed_paths!({
+                op();
+            });
+        });
 
-        self.is_in_sandbox.store(false, std::sync::atomic::Ordering::Relaxed);
+        self.leave_query_sandbox();
+        self.is_in_sandbox.store(false, AtomicOrdering::Relaxed);
 
         self.clauses_cache.borrow_mut().clear();
         self.highest_var_in_clauses_cache.borrow_mut().clear();