Load the query result cache with a query

Author: Zoxc

src/librustc/dep_graph/graph.rs

@@ -810,8 +810,7 @@ impl DepGraph {
 
         // ... emitting any stored diagnostic ...
 
-        let diagnostics = tcx.queries.on_disk_cache
-                                .load_diagnostics(tcx, prev_dep_node_index);
+        let diagnostics = tcx.on_disk_cache().load_diagnostics(tcx, prev_dep_node_index);
 
         if unlikely!(diagnostics.len() > 0) {
             self.emit_diagnostics(
@@ -853,8 +852,7 @@ impl DepGraph {
             let handle = tcx.sess.diagnostic();
 
             // Promote the previous diagnostics to the current session.
-            tcx.queries.on_disk_cache
-                .store_diagnostics(dep_node_index, diagnostics.clone().into());
+            tcx.on_disk_cache().store_diagnostics(dep_node_index, diagnostics.clone().into());
 
             for diagnostic in diagnostics {
                 DiagnosticBuilder::new_diagnostic(handle, diagnostic).emit();

src/librustc/query/mod.rs

@@ -42,6 +42,12 @@ rustc_queries! {
             desc { "loading the dependency graph" }
         }
 
+        query load_query_result_cache(_: LocalCrate) -> &'tcx OnDiskCache<'tcx> {
+            no_hash
+            eval_always
+            desc { "loading the query result cache" }
+        }
+
         query parse(_: LocalCrate) -> Result<Lrc<Steal<ast::Crate>>, ErrorReported> {
             no_hash
             eval_always
@@ -105,7 +111,7 @@ rustc_queries! {
         query generics_of(key: DefId) -> &'tcx ty::Generics {
             cache { key.is_local() }
             load_cached(tcx, id) {
-                let generics: Option<ty::Generics> = tcx.queries.on_disk_cache
+                let generics: Option<ty::Generics> = tcx.on_disk_cache()
                                                         .try_load_query_result(tcx, id);
                 generics.map(|x| tcx.alloc_generics(x))
             }
@@ -181,7 +187,7 @@ rustc_queries! {
         query optimized_mir(key: DefId) -> &'tcx mir::Mir<'tcx> {
             cache { key.is_local() }
             load_cached(tcx, id) {
-                let mir: Option<crate::mir::Mir<'tcx>> = tcx.queries.on_disk_cache
+                let mir: Option<crate::mir::Mir<'tcx>> = tcx.on_disk_cache()
                                                             .try_load_query_result(tcx, id);
                 mir.map(|x| tcx.alloc_mir(x))
             }
@@ -412,7 +418,7 @@ rustc_queries! {
             cache { key.is_local() }
             load_cached(tcx, id) {
                 let typeck_tables: Option<ty::TypeckTables<'tcx>> = tcx
-                    .queries.on_disk_cache
+                    .on_disk_cache()
                     .try_load_query_result(tcx, id);
 
                 typeck_tables.map(|tables| tcx.alloc_tables(tables))
@@ -475,7 +481,7 @@ rustc_queries! {
             }
             cache { true }
             load_cached(tcx, id) {
-                tcx.queries.on_disk_cache.try_load_query_result(tcx, id).map(Ok)
+                tcx.on_disk_cache().try_load_query_result(tcx, id).map(Ok)
             }
         }
 
@@ -490,7 +496,7 @@ rustc_queries! {
             }
             cache { true }
             load_cached(tcx, id) {
-                tcx.queries.on_disk_cache.try_load_query_result(tcx, id).map(Ok)
+                tcx.on_disk_cache().try_load_query_result(tcx, id).map(Ok)
             }
         }
     }

src/librustc/ty/context.rs

@@ -37,6 +37,7 @@ use crate::ty::{InferConst, ParamConst};
 use crate::ty::GenericParamDefKind;
 use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
 use crate::ty::query;
+use crate::ty::query::OnDiskCache;
 use crate::ty::steal::Steal;
 use crate::ty::subst::{UserSubsts, UnpackedKind};
 use crate::ty::{BoundVar, BindingMode};
@@ -1033,6 +1034,8 @@ pub struct GlobalCtxt<'tcx> {
 
     metadata_dep_nodes: Once<()>,
 
+    pub on_disk_cache_store: Once<OnDiskCache<'tcx>>,
+
     pub queries: query::Queries<'tcx>,
 
     // Internal cache for metadata decoding. No need to track deps on this.
@@ -1114,7 +1117,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     #[inline(always)]
     pub fn hir(self) -> &'gcx hir_map::Map<'gcx> {
         self.hir_map.get_or_init(|| {
-            // We can use `with_ignore` here because the hir map does its own tracking
+            // We can use `ignore_deps` here because the hir map does its own tracking
             DepGraph::ignore_deps(|| self.hir_map(LOCAL_CRATE))
         })
     }
@@ -1220,7 +1223,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         local_providers: ty::query::Providers<'tcx>,
         extern_providers: ty::query::Providers<'tcx>,
         arenas: &'tcx AllArenas<'tcx>,
-        on_disk_query_result_cache: query::OnDiskCache<'tcx>,
         crate_name: Option<String>,
         tx: mpsc::Sender<Box<dyn Any + Send>>,
         io: InputsAndOutputs,
@@ -1247,10 +1249,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             lowered_hir: AtomicOnce::new(),
             hir_map: AtomicOnce::new(),
             metadata_dep_nodes: Once::new(),
+            on_disk_cache_store: Once::new(),
             queries: query::Queries::new(
                 providers,
                 extern_providers,
-                on_disk_query_result_cache,
             ),
             rcache: Default::default(),
             selection_cache: Default::default(),
@@ -1437,7 +1439,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                            -> Result<(), E::Error>
         where E: ty::codec::TyEncoder
     {
-        self.queries.on_disk_cache.serialize(self.global_tcx(), encoder)
+        self.on_disk_cache().serialize(self.global_tcx(), encoder)
     }
 
     /// This checks whether one is allowed to have pattern bindings

src/librustc/ty/query/mod.rs

@@ -48,7 +48,7 @@ use rustc_data_structures::bit_set::BitSet;
 use rustc_data_structures::indexed_vec::IndexVec;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::stable_hasher::StableVec;
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{Lrc, AtomicOnce};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_target::spec::PanicStrategy;
 

src/librustc_interface/passes.rs

@@ -12,6 +12,7 @@ use rustc::middle::{self, reachable, resolve_lifetime, stability};
 use rustc::middle::privacy::AccessLevels;
 use rustc::ty::{self, AllArenas, Resolutions, TyCtxt, GlobalCtxt};
 use rustc::ty::steal::Steal;
+use rustc::ty::query::OnDiskCache;
 use rustc::traits;
 use rustc::util::common::{time, ErrorReported};
 use rustc::util::profiling::ProfileCategory;
@@ -899,6 +900,16 @@ fn load_dep_graph<'tcx>(
     tcx.dep_graph_store.get()
 }
 
+fn load_query_result_cache<'tcx>(
+    tcx: TyCtxt<'_, 'tcx, 'tcx>,
+    _: LocalCrate,
+) -> &'tcx OnDiskCache<'tcx> {
+    time(tcx.sess, "load query result cache", || {
+        tcx.on_disk_cache_store.set(rustc_incremental::load_query_result_cache(tcx.sess));
+        tcx.on_disk_cache_store.get()
+    })
+}
+
 pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
     providers.analysis = analysis;
     providers.hir_map = hir_map;
@@ -910,6 +921,7 @@ pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
     providers.early_crate_name = early_crate_name;
     providers.dep_graph_future = dep_graph_future;
     providers.load_dep_graph = load_dep_graph;
+    providers.load_query_result_cache = load_query_result_cache;
     proc_macro_decls::provide(providers);
     plugin::build::provide(providers);
     hir::provide(providers);
@@ -970,10 +982,6 @@ pub fn create_global_ctxt(
         let global_ctxt: Option<GlobalCtxt<'_>>;
         let arenas = AllArenas::new();
 
-        let query_result_on_disk_cache = time(sess, "load query result cache", || {
-            rustc_incremental::load_query_result_cache(sess)
-        });
-
         let mut local_providers = ty::query::Providers::default();
         default_provide(&mut local_providers);
         codegen_backend.provide(&mut local_providers);
@@ -989,7 +997,6 @@ pub fn create_global_ctxt(
             local_providers,
             extern_providers,
             &arenas,
-            query_result_on_disk_cache,
             crate_name,
             tx,
             io,