Stop parametrizing DepGraph by Deps.

Author: cjgillot

compiler/rustc_incremental/src/persist/save.rs

@@ -3,7 +3,7 @@ use crate::errors;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::join;
 use rustc_middle::dep_graph::{
- DepGraph, SerializedDepGraph, WorkProduct, WorkProductId, WorkProductMap,
+ DepGraph, DepsType, SerializedDepGraph, WorkProduct, WorkProductId, WorkProductMap,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
@@ -171,7 +171,7 @@ pub(crate) fn build_dep_graph(
  // First encode the commandline arguments hash
  sess.opts.dep_tracking_hash(false).encode(&mut encoder);
 
- Some(DepGraph::new(
+ Some(DepGraph::new::<DepsType>(
  &sess.prof,
  prev_graph,
  prev_work_products,

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -16,7 +16,7 @@ pub use rustc_query_system::dep_graph::{
 pub use dep_node::{dep_kinds, label_strs, DepKind, DepNode, DepNodeExt};
 pub(crate) use dep_node::{make_compile_codegen_unit, make_compile_mono_item};
 
-pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepsType>;
+pub type DepGraph = rustc_query_system::dep_graph::DepGraph;
 
 pub type DepKindStruct<'tcx> = rustc_query_system::dep_graph::DepKindStruct<TyCtxt<'tcx>>;
 
@@ -30,8 +30,6 @@ impl Deps for DepsType {
 }
 
 impl<'tcx> DepContext for TyCtxt<'tcx> {
- type Deps = DepsType;
-
  #[inline]
  fn with_stable_hashing_context<R>(self, f: impl FnOnce(StableHashingContext<'_>) -> R) -> R {
  TyCtxt::with_stable_hashing_context(self, f)

compiler/rustc_query_impl/src/plumbing.rs

@@ -51,7 +51,6 @@ impl<'tcx> std::ops::Deref for QueryCtxt<'tcx> {
 }
 
 impl<'tcx> HasDepContext for QueryCtxt<'tcx> {
- type Deps = rustc_middle::dep_graph::DepsType;
  type DepContext = TyCtxt<'tcx>;
 
  #[inline]

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -26,8 +26,8 @@ use crate::query::{QueryContext, QuerySideEffects};
 use {super::debug::EdgeFilter, std::env};
 
 #[derive(Clone)]
-pub struct DepGraph<D: Deps> {
- data: Option<Lrc<DepGraphData<D>>>,
+pub struct DepGraph {
+ data: Option<Lrc<DepGraphData>>,
 
  /// This field is used for assigning DepNodeIndices when running in
  /// non-incremental mode. Even in non-incremental mode we make sure that
@@ -73,12 +73,12 @@ impl DepNodeColor {
  }
 }
 
-pub(crate) struct DepGraphData<D: Deps> {
+pub(crate) struct DepGraphData {
  /// The new encoding of the dependency graph, optimized for red/green
  /// tracking. The `current` field is the dependency graph of only the
  /// current compilation session: We don't merge the previous dep-graph into
  /// current one anymore, but we do reference shared data to save space.
- current: CurrentDepGraph<D>,
+ current: CurrentDepGraph,
 
  /// The dep-graph from the previous compilation session. It contains all
  /// nodes and edges as well as all fingerprints of nodes that have them.
@@ -111,18 +111,18 @@ where
  stable_hasher.finish()
 }
 
-impl<D: Deps> DepGraph<D> {
- pub fn new(
+impl DepGraph {
+ pub fn new<D: Deps>(
  profiler: &SelfProfilerRef,
  prev_graph: SerializedDepGraph,
  prev_work_products: WorkProductMap,
  encoder: FileEncoder,
  record_graph: bool,
  record_stats: bool,
- ) -> DepGraph<D> {
+ ) -> DepGraph {
  let prev_graph_node_count = prev_graph.node_count();
 
- let current = CurrentDepGraph::new(
+ let current = CurrentDepGraph::new::<D>(
  profiler,
  prev_graph_node_count,
  encoder,
@@ -179,12 +179,12 @@ impl<D: Deps> DepGraph<D> {
  }
  }
 
- pub fn new_disabled() -> DepGraph<D> {
+ pub fn new_disabled() -> DepGraph {
  DepGraph { data: None, virtual_dep_node_index: Lrc::new(AtomicU32::new(0)) }
  }
 
  #[inline]
- pub(crate) fn data(&self) -> Option<&DepGraphData<D>> {
+ pub(crate) fn data(&self) -> Option<&DepGraphData> {
  self.data.as_deref()
  }
 
@@ -273,7 +273,7 @@ impl<D: Deps> DepGraph<D> {
  }
 
  #[inline(always)]
- pub fn with_task<Ctxt: HasDepContext<Deps = D>, A: Debug, R>(
+ pub fn with_task<Ctxt: HasDepContext, A: Debug, R>(
  &self,
  key: DepNode,
  cx: Ctxt,
@@ -287,7 +287,7 @@ impl<D: Deps> DepGraph<D> {
  }
  }
 
- pub fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>(
+ pub fn with_anon_task<Tcx: DepContext, OP, R>(
  &self,
  cx: Tcx,
  dep_kind: DepKind,
@@ -303,7 +303,7 @@ impl<D: Deps> DepGraph<D> {
  }
 }
 
-impl<D: Deps> DepGraphData<D> {
+impl DepGraphData {
  /// Starts a new dep-graph task. Dep-graph tasks are specified
  /// using a free function (`task`) and **not** a closure -- this
  /// is intentional because we want to exercise tight control over
@@ -332,7 +332,7 @@ impl<D: Deps> DepGraphData<D> {
  ///
  /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/queries/incremental-compilation.html
  #[inline(always)]
- pub(crate) fn with_task<Ctxt: HasDepContext<Deps = D>, A: Debug, R>(
+ pub(crate) fn with_task<Ctxt: HasDepContext, A: Debug, R>(
  &self,
  key: DepNode,
  cx: Ctxt,
@@ -397,7 +397,7 @@ impl<D: Deps> DepGraphData<D> {
 
  /// Executes something within an "anonymous" task, that is, a task the
  /// `DepNode` of which is determined by the list of inputs it read from.
- pub(crate) fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>(
+ pub(crate) fn with_anon_task<Tcx: DepContext, OP, R>(
  &self,
  cx: Tcx,
  dep_kind: DepKind,
@@ -456,7 +456,7 @@ impl<D: Deps> DepGraphData<D> {
  }
 }
 
-impl<D: Deps> DepGraph<D> {
+impl DepGraph {
  #[inline]
  pub fn read_index(&self, dep_node_index: DepNodeIndex) {
  if let Some(ref data) = self.data {
@@ -527,7 +527,7 @@ impl<D: Deps> DepGraph<D> {
  /// FIXME: If the code is changed enough for this node to be marked before requiring the
  /// caller's node, we suppose that those changes will be enough to mark this node red and
  /// force a recomputation using the "normal" way.
- pub fn with_feed_task<Ctxt: DepContext<Deps = D>, A: Debug, R: Debug>(
+ pub fn with_feed_task<Ctxt: DepContext, A: Debug, R: Debug>(
  &self,
  node: DepNode,
  cx: Ctxt,
@@ -615,7 +615,7 @@ impl<D: Deps> DepGraph<D> {
  }
 }
 
-impl<D: Deps> DepGraphData<D> {
+impl DepGraphData {
  #[inline]
  fn dep_node_index_of_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex> {
  if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
@@ -661,7 +661,7 @@ impl<D: Deps> DepGraphData<D> {
  }
 }
 
-impl<D: Deps> DepGraph<D> {
+impl DepGraph {
  #[inline]
  pub fn dep_node_exists(&self, dep_node: &DepNode) -> bool {
  self.data.as_ref().is_some_and(|data| data.dep_node_exists(dep_node))
@@ -710,7 +710,7 @@ impl<D: Deps> DepGraph<D> {
  None
  }
 
- pub fn try_mark_green<Qcx: QueryContext<Deps = D>>(
+ pub fn try_mark_green<Qcx: QueryContext>(
  &self,
  qcx: Qcx,
  dep_node: &DepNode,
@@ -719,13 +719,13 @@ impl<D: Deps> DepGraph<D> {
  }
 }
 
-impl<D: Deps> DepGraphData<D> {
+impl DepGraphData {
  /// Try to mark a node index for the node dep_node.
  ///
  /// A node will have an index, when it's already been marked green, or when we can mark it
  /// green. This function will mark the current task as a reader of the specified node, when
  /// a node index can be found for that node.
- pub(crate) fn try_mark_green<Qcx: QueryContext<Deps = D>>(
+ pub(crate) fn try_mark_green<Qcx: QueryContext>(
  &self,
  qcx: Qcx,
  dep_node: &DepNode,
@@ -750,7 +750,7 @@ impl<D: Deps> DepGraphData<D> {
  }
 
  #[instrument(skip(self, qcx, parent_dep_node_index, frame), level = "debug")]
- fn try_mark_parent_green<Qcx: QueryContext<Deps = D>>(
+ fn try_mark_parent_green<Qcx: QueryContext>(
  &self,
  qcx: Qcx,
  parent_dep_node_index: SerializedDepNodeIndex,
@@ -838,7 +838,7 @@ impl<D: Deps> DepGraphData<D> {
 
  /// Try to mark a dep-node which existed in the previous compilation session as green.
  #[instrument(skip(self, qcx, prev_dep_node_index, frame), level = "debug")]
- fn try_mark_previous_green<Qcx: QueryContext<Deps = D>>(
+ fn try_mark_previous_green<Qcx: QueryContext>(
  &self,
  qcx: Qcx,
  prev_dep_node_index: SerializedDepNodeIndex,
@@ -909,7 +909,7 @@ impl<D: Deps> DepGraphData<D> {
  /// This may be called concurrently on multiple threads for the same dep node.
  #[cold]
  #[inline(never)]
- fn emit_side_effects<Qcx: QueryContext<Deps = D>>(
+ fn emit_side_effects<Qcx: QueryContext>(
  &self,
  qcx: Qcx,
  dep_node_index: DepNodeIndex,
@@ -933,7 +933,7 @@ impl<D: Deps> DepGraphData<D> {
  }
 }
 
-impl<D: Deps> DepGraph<D> {
+impl DepGraph {
  /// Returns true if the given node has been marked as red during the
  /// current compilation session. Used in various assertions
  pub fn is_red(&self, dep_node: &DepNode) -> bool {
@@ -1069,8 +1069,8 @@ rustc_index::newtype_index! {
 /// `new_node_to_index` and `data`, or `prev_index_to_index` and `data`. When
 /// manipulating both, we acquire `new_node_to_index` or `prev_index_to_index`
 /// first, and `data` second.
-pub(super) struct CurrentDepGraph<D: Deps> {
- encoder: Steal<GraphEncoder<D>>,
+pub(super) struct CurrentDepGraph {
+ encoder: Steal<GraphEncoder>,
  new_node_to_index: Sharded<FxHashMap<DepNode, DepNodeIndex>>,
  prev_index_to_index: Lock<IndexVec<SerializedDepNodeIndex, Option<DepNodeIndex>>>,
 
@@ -1109,8 +1109,8 @@ pub(super) struct CurrentDepGraph<D: Deps> {
  node_intern_event_id: Option<EventId>,
 }
 
-impl<D: Deps> CurrentDepGraph<D> {
- fn new(
+impl CurrentDepGraph {
+ fn new<D: Deps>(
  profiler: &SelfProfilerRef,
  prev_graph_node_count: usize,
  encoder: FileEncoder,
@@ -1146,7 +1146,7 @@ impl<D: Deps> CurrentDepGraph<D> {
  .map(EventId::from_label);
 
  CurrentDepGraph {
- encoder: Steal::new(GraphEncoder::new(
+ encoder: Steal::new(GraphEncoder::new::<D>(
  encoder,
  prev_graph_node_count,
  record_graph,
@@ -1392,7 +1392,7 @@ impl DepNodeColorMap {
 
 #[inline(never)]
 #[cold]
-pub(crate) fn print_markframe_trace<D: Deps>(graph: &DepGraph<D>, frame: Option<&MarkFrame<'_>>) {
+pub(crate) fn print_markframe_trace(graph: &DepGraph, frame: Option<&MarkFrame<'_>>) {
  let data = graph.data.as_ref().unwrap();
 
  eprintln!("there was a panic while trying to force a dep node");

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -20,13 +20,11 @@ use std::panic;
 use self::graph::{print_markframe_trace, MarkFrame};
 
 pub trait DepContext: Copy {
- type Deps: Deps;
-
  /// Create a hashing context for hashing new results.
  fn with_stable_hashing_context<R>(self, f: impl FnOnce(StableHashingContext<'_>) -> R) -> R;
 
  /// Access the DepGraph.
- fn dep_graph(&self) -> &DepGraph<Self::Deps>;
+ fn dep_graph(&self) -> &DepGraph;
 
  /// Access the profiler.
  fn profiler(&self) -> &SelfProfilerRef;
@@ -80,7 +78,7 @@ pub trait DepContext: Copy {
  }
 }
 
-pub trait Deps {
+pub trait Deps: 'static {
  /// We use this for most things when incr. comp. is turned off.
  const DEP_KIND_NULL: DepKind;
 
@@ -93,14 +91,12 @@ pub trait Deps {
 }
 
 pub trait HasDepContext: Copy {
- type Deps: self::Deps;
- type DepContext: self::DepContext<Deps = Self::Deps>;
+ type DepContext: self::DepContext;
 
  fn dep_context(&self) -> &Self::DepContext;
 }
 
 impl<T: DepContext> HasDepContext for T {
- type Deps = T::Deps;
  type DepContext = Self;
 
  fn dep_context(&self) -> &Self::DepContext {
@@ -109,7 +105,6 @@ impl<T: DepContext> HasDepContext for T {
 }
 
 impl<T: HasDepContext, Q: Copy> HasDepContext for (T, Q) {
- type Deps = T::Deps;
  type DepContext = T::DepContext;
 
  fn dep_context(&self) -> &Self::DepContext {