Type-erase query caching.

Author: cjgillot

compiler/rustc_macros/src/query.rs

@@ -466,6 +466,10 @@ pub fn rustc_queries(input: TokenStream) -> TokenStream {
             if modifiers.eval_always {
                 attributes.push(quote! { eval_always });
             };
+            // Pass on the cache modifier
+            if modifiers.cache.is_some() {
+                attributes.push(quote! { cached });
+            };
 
             let attribute_stream = quote! {#(#attributes),*};
             let doc_comments = query.doc_comments.iter();

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -67,7 +67,7 @@ use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX};
 use rustc_hir::definitions::DefPathHash;
 use rustc_hir::HirId;
 use rustc_query_system::query::QueryAccessors;
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder};
 use rustc_span::symbol::Symbol;
 use std::hash::Hash;
 
@@ -84,6 +84,13 @@ pub trait DepKindTrait: std::fmt::Debug + Sync {
 
     fn has_params(&self) -> bool;
 
+    fn encode_query_results<'a, 'tcx>(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+        query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+    );
+
     fn force_from_dep_node(&self, tcx: TyCtxt<'_>, dep_node: &DepNode) -> bool;
 
     fn query_stats(&self, tcx: TyCtxt<'_>) -> Option<query::stats::QueryStats>;
@@ -124,6 +131,19 @@ macro_rules! contains_eval_always_attr {
     ($($attr:ident $(($($attr_args:tt)*))* ),*) => ({$(is_eval_always_attr!($attr) | )* false});
 }
 
+macro_rules! encode_query_results {
+    ([][$variant:ident][$($args:expr),*]) => {{}};
+    ([cached $($rest:tt)*][$variant:ident][$($args:expr),*]) => {{
+        let ret = query::on_disk_cache::encode_query_results::<
+            query::queries::$variant<'_>
+        >($($args),*);
+        match ret { Ok(()) => (), Err(_) => () }
+    }};
+    ([$other:ident $(($($other_args:tt)*))* $(, $($modifiers:tt)*)*][$variant:ident][$($args:expr),*]) => {
+        encode_query_results!([$($($modifiers)*)*][$variant][$($args),*])
+    };
+}
+
 macro_rules! define_dep_kinds {
     (<$tcx:tt>
     $(
@@ -176,6 +196,16 @@ macro_rules! define_dep_kinds {
                 false
             }
 
+            #[inline]
+            fn encode_query_results<'a, 'tcx>(
+                &self,
+                _tcx: TyCtxt<'tcx>,
+                _encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+                _query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+            ) {
+                encode_query_results!([$($attrs)*][$variant][_tcx, _encoder, _query_result_index]);
+            }
+
             #[inline]
             fn force_from_dep_node(&self, tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> bool {
                 use rustc_query_system::query::force_query;
@@ -422,6 +452,15 @@ impl DepKindTrait for dep_kind::Null {
         false
     }
 
+    #[inline]
+    fn encode_query_results<'a, 'tcx>(
+        &self,
+        _tcx: TyCtxt<'tcx>,
+        _encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+        _query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+    ) {
+    }
+
     #[inline]
     fn force_from_dep_node(&self, _tcx: TyCtxt<'tcx>, _dep_node: &DepNode) -> bool {
         // Forcing this makes no sense.
@@ -463,6 +502,15 @@ impl DepKindTrait for dep_kind::CrateMetadata {
         true
     }
 
+    #[inline]
+    fn encode_query_results<'a, 'tcx>(
+        &self,
+        _tcx: TyCtxt<'tcx>,
+        _encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+        _query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+    ) {
+    }
+
     #[inline]
     fn force_from_dep_node(&self, _tcx: TyCtxt<'tcx>, _dep_node: &DepNode) -> bool {
         // These are inputs that are expected to be pre-allocated and that
@@ -509,6 +557,15 @@ impl DepKindTrait for dep_kind::TraitSelect {
         false
     }
 
+    #[inline]
+    fn encode_query_results<'a, 'tcx>(
+        &self,
+        _tcx: TyCtxt<'tcx>,
+        _encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+        _query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+    ) {
+    }
+
     #[inline]
     fn force_from_dep_node(&self, _tcx: TyCtxt<'tcx>, _dep_node: &DepNode) -> bool {
         // These are anonymous nodes.
@@ -555,6 +612,15 @@ impl DepKindTrait for dep_kind::CompileCodegenUnit {
         true
     }
 
+    #[inline]
+    fn encode_query_results<'a, 'tcx>(
+        &self,
+        _tcx: TyCtxt<'tcx>,
+        _encoder: &mut query::on_disk_cache::CacheEncoder<'a, 'tcx, opaque::Encoder>,
+        _query_result_index: &mut query::on_disk_cache::EncodedQueryResultIndex,
+    ) {
+    }
+
     #[inline]
     fn force_from_dep_node(&self, _tcx: TyCtxt<'tcx>, _dep_node: &DepNode) -> bool {
         // We don't have enough information to reconstruct the query key of these.

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

@@ -83,7 +83,7 @@ use rustc_query_system::query::QueryAccessors;
 pub use rustc_query_system::query::QueryConfig;
 pub(crate) use rustc_query_system::query::QueryDescription;
 
-mod on_disk_cache;
+pub mod on_disk_cache;
 pub use self::on_disk_cache::OnDiskCache;
 
 mod profiling_support;

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

@@ -97,15 +97,15 @@ struct Footer {
     expn_data: FxHashMap<u32, AbsoluteBytePos>,
 }
 
-type EncodedQueryResultIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
+pub type EncodedQueryResultIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
 type EncodedDiagnosticsIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
 type EncodedDiagnostics = Vec<Diagnostic>;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)]
 struct SourceFileIndex(u32);
 
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Encodable, Decodable)]
-struct AbsoluteBytePos(u32);
+pub struct AbsoluteBytePos(u32);
 
 impl AbsoluteBytePos {
     fn new(pos: usize) -> AbsoluteBytePos {
@@ -226,22 +226,10 @@ impl<'sess> OnDiskCache<'sess> {
                 let enc = &mut encoder;
                 let qri = &mut query_result_index;
 
-                macro_rules! encode_queries {
-                    ($($query:ident,)*) => {
-                        $(
-                            encode_query_results::<ty::query::queries::$query<'_>>(
-                                tcx,
-                                enc,
-                                qri
-                            )?;
-                        )*
-                    }
+                for dk in rustc_middle::dep_graph::DEP_KINDS {
+                    dk.encode_query_results(tcx, enc, qri)
                 }
-
-                rustc_cached_queries!(encode_queries!);
-
-                Ok(())
-            })?;
+            });
 
             // Encode diagnostics.
             let diagnostics_index: EncodedDiagnosticsIndex = self
@@ -765,7 +753,7 @@ impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [Span] {
 //- ENCODING -------------------------------------------------------------------
 
 /// This trait is a hack to work around specialization bug #55243.
-trait OpaqueEncoder: Encoder {
+pub trait OpaqueEncoder: Encoder {
     fn opaque(&mut self) -> &mut opaque::Encoder;
     fn encoder_position(&self) -> usize;
 }
@@ -782,7 +770,7 @@ impl OpaqueEncoder for opaque::Encoder {
 }
 
 /// An encoder that can write the incr. comp. cache.
-struct CacheEncoder<'a, 'tcx, E: OpaqueEncoder> {
+pub struct CacheEncoder<'a, 'tcx, E: OpaqueEncoder> {
     tcx: TyCtxt<'tcx>,
     encoder: &'a mut E,
     type_shorthands: FxHashMap<Ty<'tcx>, usize>,
@@ -1005,7 +993,7 @@ impl<'a> Decodable<opaque::Decoder<'a>> for IntEncodedWithFixedSize {
     }
 }
 
-fn encode_query_results<'a, 'tcx, Q>(
+pub fn encode_query_results<'a, 'tcx, Q>(
     tcx: TyCtxt<'tcx>,
     encoder: &mut CacheEncoder<'a, 'tcx, opaque::Encoder>,
     query_result_index: &mut EncodedQueryResultIndex,