Replace DepKind by trait objects

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,