Introduce a OnDiskCache trait.

Author: cjgillot

compiler/rustc_incremental/src/persist/save.rs

@@ -235,7 +235,5 @@ fn encode_work_product_index(
 }
 
 fn encode_query_cache(tcx: TyCtxt<'_>, encoder: &mut Encoder) {
-    tcx.sess.time("incr_comp_serialize_result_cache", || {
-        tcx.serialize_query_result_cache(encoder).unwrap();
-    })
+    tcx.sess.time("incr_comp_serialize_result_cache", || tcx.serialize_query_result_cache(encoder))
 }

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -1,10 +1,9 @@
 use crate::ich::StableHashingContext;
 use crate::ty::query::try_load_from_on_disk_cache;
+use crate::ty::query::OnDiskCache;
 use crate::ty::{self, TyCtxt};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sync::Lock;
-use rustc_data_structures::thin_vec::ThinVec;
-use rustc_errors::Diagnostic;
 use rustc_hir::def_id::{DefPathHash, LocalDefId};
 use rustc_session::Session;
 
@@ -90,6 +89,7 @@ impl rustc_query_system::dep_graph::DepKind for DepKind {
 
 impl<'tcx> DepContext for TyCtxt<'tcx> {
     type DepKind = DepKind;
+    type OnDiskCache = OnDiskCache<'tcx>;
     type StableHashingContext = StableHashingContext<'tcx>;
 
     fn register_reused_dep_path_hash(&self, hash: DefPathHash) {
@@ -102,6 +102,11 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
         TyCtxt::create_stable_hashing_context(*self)
     }
 
+    #[inline(always)]
+    fn on_disk_cache(&self) -> Option<&OnDiskCache<'tcx>> {
+        self.queries.on_disk_cache.as_ref()
+    }
+
     #[inline(always)]
     fn profiler(&self) -> &SelfProfilerRef {
         &self.prof
@@ -163,30 +168,6 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
     fn try_load_from_on_disk_cache(&self, dep_node: &DepNode) {
         try_load_from_on_disk_cache(*self, dep_node)
     }
-
-    fn load_diagnostics(&self, prev_dep_node_index: SerializedDepNodeIndex) -> Vec<Diagnostic> {
-        self.queries
-            .on_disk_cache
-            .as_ref()
-            .map(|c| c.load_diagnostics(*self, prev_dep_node_index))
-            .unwrap_or_default()
-    }
-
-    fn store_diagnostics(&self, dep_node_index: DepNodeIndex, diagnostics: ThinVec<Diagnostic>) {
-        if let Some(c) = self.queries.on_disk_cache.as_ref() {
-            c.store_diagnostics(dep_node_index, diagnostics)
-        }
-    }
-
-    fn store_diagnostics_for_anon_node(
-        &self,
-        dep_node_index: DepNodeIndex,
-        diagnostics: ThinVec<Diagnostic>,
-    ) {
-        if let Some(c) = self.queries.on_disk_cache.as_ref() {
-            c.store_diagnostics_for_anon_node(dep_node_index, diagnostics)
-        }
-    }
 }
 
 fn def_id_corresponds_to_hir_dep_node(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {

compiler/rustc_middle/src/ty/context.rs

@@ -47,6 +47,7 @@ use rustc_hir::{
 };
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_macros::HashStable;
+use rustc_query_system::dep_graph::OnDiskCache as _;
 use rustc_serialize::opaque;
 use rustc_session::config::{BorrowckMode, CrateType, OutputFilenames};
 use rustc_session::lint::{Level, Lint};
@@ -1336,8 +1337,8 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
-    pub fn serialize_query_result_cache(self, encoder: &mut opaque::Encoder) -> Result<(), !> {
-        self.queries.on_disk_cache.as_ref().map(|c| c.serialize(self, encoder)).unwrap_or(Ok(()))
+    pub fn serialize_query_result_cache(self, encoder: &mut opaque::Encoder) {
+        self.queries.on_disk_cache.as_ref().map(|c| c.serialize(self, encoder)).unwrap_or(())
     }
 
     /// If `true`, we should use the MIR-based borrowck, but also

compiler/rustc_middle/src/ty/query/on_disk_cache.rs

@@ -239,14 +239,12 @@ impl<'sess> OnDiskCache<'sess> {
             def_path_hash_to_def_id_cache: Default::default(),
         }
     }
+}
 
-    crate fn serialize<'tcx>(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        encoder: &mut opaque::Encoder,
-    ) -> Result<(), !> {
+impl<'tcx> rustc_query_system::dep_graph::OnDiskCache<TyCtxt<'tcx>> for OnDiskCache<'tcx> {
+    fn serialize(&self, tcx: TyCtxt<'tcx>, encoder: &mut opaque::Encoder) {
         // Serializing the `DepGraph` should not modify it.
-        tcx.dep_graph.with_ignore(|| {
+        let ret: Result<(), !> = tcx.dep_graph.with_ignore(|| {
             // Allocate `SourceFileIndex`es.
             let (file_to_file_index, file_index_to_stable_id) = {
                 let files = tcx.sess.source_map().files();
@@ -418,11 +416,12 @@ impl<'sess> OnDiskCache<'sess> {
                 cnums.dedup();
                 cnums
             }
-        })
+        });
+        ret.unwrap()
     }
 
     /// Loads a diagnostic emitted during the previous compilation session.
-    crate fn load_diagnostics(
+    fn load_diagnostics(
         &self,
         tcx: TyCtxt<'_>,
         dep_node_index: SerializedDepNodeIndex,
@@ -438,16 +437,32 @@ impl<'sess> OnDiskCache<'sess> {
     /// the next compilation session.
     #[inline(never)]
     #[cold]
-    crate fn store_diagnostics(
+    fn store_diagnostics(&self, dep_node_index: DepNodeIndex, diagnostics: ThinVec<Diagnostic>) {
+        let mut current_diagnostics = self.current_diagnostics.borrow_mut();
+        let prev = current_diagnostics.insert(dep_node_index, diagnostics.into());
+        debug_assert!(prev.is_none());
+    }
+
+    /// Stores a diagnostic emitted during computation of an anonymous query.
+    /// Since many anonymous queries can share the same `DepNode`, we aggregate
+    /// them -- as opposed to regular queries where we assume that there is a
+    /// 1:1 relationship between query-key and `DepNode`.
+    #[inline(never)]
+    #[cold]
+    fn store_diagnostics_for_anon_node(
         &self,
         dep_node_index: DepNodeIndex,
         diagnostics: ThinVec<Diagnostic>,
     ) {
         let mut current_diagnostics = self.current_diagnostics.borrow_mut();
-        let prev = current_diagnostics.insert(dep_node_index, diagnostics.into());
-        debug_assert!(prev.is_none());
+
+        let x = current_diagnostics.entry(dep_node_index).or_insert(Vec::new());
+
+        x.extend(Into::<Vec<_>>::into(diagnostics));
     }
+}
 
+impl<'sess> OnDiskCache<'sess> {
     fn get_raw_def_id(&self, hash: &DefPathHash) -> Option<RawDefId> {
         self.foreign_def_path_hashes.get(hash).copied()
     }
@@ -500,24 +515,6 @@ impl<'sess> OnDiskCache<'sess> {
         self.load_indexed(tcx, dep_node_index, &self.query_result_index, "query result")
     }
 
-    /// Stores a diagnostic emitted during computation of an anonymous query.
-    /// Since many anonymous queries can share the same `DepNode`, we aggregate
-    /// them -- as opposed to regular queries where we assume that there is a
-    /// 1:1 relationship between query-key and `DepNode`.
-    #[inline(never)]
-    #[cold]
-    crate fn store_diagnostics_for_anon_node(
-        &self,
-        dep_node_index: DepNodeIndex,
-        diagnostics: ThinVec<Diagnostic>,
-    ) {
-        let mut current_diagnostics = self.current_diagnostics.borrow_mut();
-
-        let x = current_diagnostics.entry(dep_node_index).or_insert(Vec::new());
-
-        x.extend(Into::<Vec<_>>::into(diagnostics));
-    }
-
     fn load_indexed<'tcx, T>(
         &self,
         tcx: TyCtxt<'tcx>,

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -21,7 +21,7 @@ use super::debug::EdgeFilter;
 use super::prev::PreviousDepGraph;
 use super::query::DepGraphQuery;
 use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
-use super::{DepContext, DepKind, DepNode, WorkProductId};
+use super::{DepContext, DepKind, DepNode, OnDiskCache, WorkProductId};
 
 #[derive(Clone)]
 pub struct DepGraph<K: DepKind> {
@@ -703,7 +703,10 @@ impl<K: DepKind> DepGraph<K> {
 
         // FIXME: Store the fact that a node has diagnostics in a bit in the dep graph somewhere
         // Maybe store a list on disk and encode this fact in the DepNodeState
-        let diagnostics = tcx.load_diagnostics(prev_dep_node_index);
+        let diagnostics = tcx
+            .on_disk_cache()
+            .map(|c| c.load_diagnostics(tcx, prev_dep_node_index))
+            .unwrap_or(Vec::new());
 
         #[cfg(not(parallel_compiler))]
         debug_assert!(
@@ -751,7 +754,9 @@ impl<K: DepKind> DepGraph<K> {
             mem::drop(emitting);
 
             // Promote the previous diagnostics to the current session.
-            tcx.store_diagnostics(dep_node_index, diagnostics.clone().into());
+            if let Some(c) = tcx.on_disk_cache() {
+                c.store_diagnostics(dep_node_index, diagnostics.clone().into());
+            }
 
             let handle = tcx.sess().diagnostic();
 

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -15,6 +15,7 @@ use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sync::Lock;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::Diagnostic;
+use rustc_serialize::opaque;
 use rustc_session::Session;
 use rustc_span::def_id::DefPathHash;
 
@@ -23,6 +24,7 @@ use std::hash::Hash;
 
 pub trait DepContext: Copy {
     type DepKind: self::DepKind;
+    type OnDiskCache: self::OnDiskCache<Self>;
     type StableHashingContext;
 
     /// Create a hashing context for hashing new results.
@@ -36,24 +38,37 @@ pub trait DepContext: Copy {
     /// Load data from the on-disk cache.
     fn try_load_from_on_disk_cache(&self, dep_node: &DepNode<Self::DepKind>);
 
-    /// Load diagnostics associated to the node in the previous session.
-    fn load_diagnostics(&self, prev_dep_node_index: SerializedDepNodeIndex) -> Vec<Diagnostic>;
+    /// Access the on_disk_cache.
+    fn on_disk_cache(&self) -> Option<&Self::OnDiskCache>;
 
-    /// Register diagnostics for the given node, for use in next session.
+    /// Access the profiler.
+    fn profiler(&self) -> &SelfProfilerRef;
+
+    /// Access the compiler session.
+    fn sess(&self) -> &Session;
+}
+
+pub trait OnDiskCache<CTX> {
+    fn serialize(&self, tcx: CTX, encoder: &mut opaque::Encoder);
+
+    /// Loads a diagnostic emitted during the previous compilation session.
+    fn load_diagnostics(&self, tcx: CTX, dep_node_index: SerializedDepNodeIndex)
+    -> Vec<Diagnostic>;
+
+    /// Stores a diagnostic emitted during the current compilation session.
+    /// Anything stored like this will be available via `load_diagnostics` in
+    /// the next compilation session.
     fn store_diagnostics(&self, dep_node_index: DepNodeIndex, diagnostics: ThinVec<Diagnostic>);
 
-    /// Register diagnostics for the given node, for use in next session.
+    /// Stores a diagnostic emitted during computation of an anonymous query.
+    /// Since many anonymous queries can share the same `DepNode`, we aggregate
+    /// them -- as opposed to regular queries where we assume that there is a
+    /// 1:1 relationship between query-key and `DepNode`.
     fn store_diagnostics_for_anon_node(
         &self,
         dep_node_index: DepNodeIndex,
         diagnostics: ThinVec<Diagnostic>,
     );
-
-    /// Access the profiler.
-    fn profiler(&self) -> &SelfProfilerRef;
-
-    /// Access the compiler session.
-    fn sess(&self) -> &Session;
 }
 
 /// Describe the different families of dependency nodes.

compiler/rustc_query_system/src/query/plumbing.rs

@@ -2,7 +2,7 @@
 //! generate the actual methods on tcx which find and execute the provider,
 //! manage the caches, and so forth.
 
-use crate::dep_graph::{DepKind, DepNode};
+use crate::dep_graph::{DepKind, DepNode, OnDiskCache};
 use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 use crate::query::caches::QueryCache;
 use crate::query::config::{QueryDescription, QueryVtable, QueryVtableExt};
@@ -440,7 +440,9 @@ where
         tcx.dep_graph().read_index(dep_node_index);
 
         if unlikely!(!diagnostics.is_empty()) {
-            tcx.store_diagnostics_for_anon_node(dep_node_index, diagnostics);
+            if let Some(c) = tcx.on_disk_cache() {
+                c.store_diagnostics_for_anon_node(dep_node_index, diagnostics);
+            }
         }
 
         return job.complete(result, dep_node_index);
@@ -613,7 +615,9 @@ where
     prof_timer.finish_with_query_invocation_id(dep_node_index.into());
 
     if unlikely!(!diagnostics.is_empty()) && dep_node.kind != DepKind::NULL {
-        tcx.store_diagnostics(dep_node_index, diagnostics);
+        if let Some(c) = tcx.on_disk_cache() {
+            c.store_diagnostics(dep_node_index, diagnostics);
+        }
     }
 
     let result = job.complete(result, dep_node_index);