Remove FrozenLinkedGraph

zetanumbers · zetanumbers · commit ddde5c6a88a6 · 2026-01-29T18:43:24.000+03:00
diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
@@ -21,8 +21,6 @@
 //! be indexed by the direction (see the type `Direction`).
 
 use std::fmt::Debug;
-use std::mem;
-use std::ops::Deref;
 
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::{Idx, IndexVec};
@@ -47,32 +45,18 @@ mod tests;
 /// This graph implementation predates the later [graph traits](crate::graph),
 /// and does not implement those traits, so it has its own implementations of a
 /// few basic graph algorithms.
-#[derive(Clone)]
 pub struct LinkedGraph<I: Idx, N, E> {
     nodes: IndexVec<I, Option<Node<N>>>,
     edges: Vec<Edge<I, E>>,
+    linked_edges: usize,
 }
 
-#[derive(Clone)]
-pub struct FrozenLinkedGraph<I: Idx, N, E> {
-    inner: LinkedGraph<I, N, E>,
-}
-
-impl<I: Idx, N, E> Deref for FrozenLinkedGraph<I, N, E> {
-    type Target = LinkedGraph<I, N, E>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-#[derive(Clone)]
 pub struct Node<N> {
     first_edge: [EdgeIndex; 2], // see module comment
     pub data: N,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Edge<I, E> {
     next_edge: [EdgeIndex; 2], // see module comment
     source: I,
@@ -97,18 +81,26 @@ pub const INCOMING: Direction = Direction { repr: 1 };
 
 impl<I: Idx, N, E> LinkedGraph<I, N, E> {
     pub fn new() -> Self {
-        Self { nodes: IndexVec::new(), edges: Vec::new() }
+        Self { nodes: IndexVec::new(), edges: Vec::new(), linked_edges: 0 }
     }
 
     pub fn from_node_n(data: N, n: usize) -> Self
     where
         N: Copy,
     {
-        Self { nodes: IndexVec::from_fn_n(|_| Some(Node::new(data)), n), edges: Vec::new() }
+        Self {
+            nodes: IndexVec::from_fn_n(|_| Some(Node::new(data)), n),
+            edges: Vec::new(),
+            linked_edges: 0,
+        }
     }
 
     pub fn with_capacity(nodes: usize, edges: usize) -> Self {
-        Self { nodes: IndexVec::with_capacity(nodes), edges: Vec::with_capacity(edges) }
+        Self {
+            nodes: IndexVec::with_capacity(nodes),
+            edges: Vec::with_capacity(edges),
+            linked_edges: 0,
+        }
     }
 
     // # Simple accessors
@@ -152,10 +144,6 @@ impl<I: Idx, N, E> LinkedGraph<I, N, E> {
         self.nodes[idx].as_ref().unwrap()
     }
 
-    pub fn node_mut(&mut self, idx: I) -> &mut Node<N> {
-        self.nodes[idx].as_mut().unwrap()
-    }
-
     // # Edge construction and queries
 
     pub fn next_edge_index(&self) -> EdgeIndex {
@@ -186,49 +174,32 @@ impl<I: Idx, N, E> LinkedGraph<I, N, E> {
         self.enumerated_edges().all(|(edge_idx, edge)| f(edge_idx, edge))
     }
 
-    fn generate_lists(&mut self) {
-        for (idx, edge) in self.edges.iter_mut().enumerate() {
-            // read and adjust current first of the list of edges from each node
-            let source_first = mem::replace(
-                &mut self.nodes[edge.source].as_mut().unwrap().first_edge[OUTGOING.repr],
-                EdgeIndex(idx),
-            );
-            let target_first = mem::replace(
-                &mut self.nodes[edge.target].as_mut().unwrap().first_edge[INCOMING.repr],
-                EdgeIndex(idx),
-            );
+    fn link_edges(&mut self) {
+        for (idx, edge) in self.edges.iter_mut().enumerate().skip(self.linked_edges) {
+            // read current first of the list of edges from each node
+            let (Some(Some(source_node)), Some(Some(target_node))) =
+                (self.nodes.get(edge.source), self.nodes.get(edge.target))
+            else {
+                return;
+            };
+            let source_first = source_node.first_edge[OUTGOING.repr];
+            let target_first = target_node.first_edge[INCOMING.repr];
+            self.linked_edges += 1;
 
-            // populate edges lists, with the previous firsts from each node
+            // create the new edge, with the previous firsts from each node
             // as the next pointers
             edge.next_edge = [source_first, target_first];
-        }
-    }
 
-    pub fn freeze(mut self) -> FrozenLinkedGraph<I, N, E> {
-        self.generate_lists();
-        FrozenLinkedGraph { inner: self }
-    }
-}
-
-impl<I: Idx, N: Debug, E: Debug> LinkedGraph<I, N, E> {
-    pub fn add_edge(&mut self, source: I, target: I, data: E) -> EdgeIndex {
-        debug!("graph: add_edge({:?}, {:?}, {:?})", source, target, data);
-
-        let idx = self.next_edge_index();
-        self.edges.push(Edge {
-            next_edge: [INVALID_EDGE_INDEX, INVALID_EDGE_INDEX],
-            source,
-            target,
-            data,
-        });
-        idx
+            // adjust the firsts for each node target be the next object.
+            self.nodes[edge.source].as_mut().unwrap().first_edge[OUTGOING.repr] = EdgeIndex(idx);
+            self.nodes[edge.target].as_mut().unwrap().first_edge[INCOMING.repr] = EdgeIndex(idx);
+        }
     }
-}
 
-impl<I: Idx, N, E> FrozenLinkedGraph<I, N, E> {
     pub fn adjacent_edges(&self, source: I, direction: Direction) -> AdjacentEdges<'_, I, N, E> {
-        let first_edge = self.inner.node(source).first_edge[direction.repr];
-        AdjacentEdges { graph: &self.inner, direction, next: first_edge }
+        assert_eq!(self.linked_edges, self.edges.len(), "linked graph is incomplete");
+        let first_edge = self.node(source).first_edge[direction.repr];
+        AdjacentEdges { graph: &self, direction, next: first_edge }
     }
 
     pub fn outgoing_edges(&self, source: I) -> AdjacentEdges<'_, I, N, E> {
@@ -288,6 +259,22 @@ impl<I: Idx, N, E> FrozenLinkedGraph<I, N, E> {
     }
 }
 
+impl<I: Idx, N: Debug, E: Debug> LinkedGraph<I, N, E> {
+    pub fn add_edge(&mut self, source: I, target: I, data: E) -> EdgeIndex {
+        debug!("graph: add_edge({:?}, {:?}, {:?})", source, target, data);
+
+        let idx = self.next_edge_index();
+        self.edges.push(Edge {
+            next_edge: [INVALID_EDGE_INDEX, INVALID_EDGE_INDEX],
+            source,
+            target,
+            data,
+        });
+        self.link_edges();
+        idx
+    }
+}
+
 impl<N> Node<N> {
     #[inline]
     const fn new(data: N) -> Node<N> {
@@ -334,15 +321,15 @@ impl<'g, I: Idx, N, E> Iterator for AdjacentEdges<'g, I, N, E> {
 }
 
 pub struct DepthFirstTraversal<'g, I: Idx, N, E> {
-    graph: &'g FrozenLinkedGraph<I, N, E>,
+    graph: &'g LinkedGraph<I, N, E>,
     stack: Vec<I>,
     visited: DenseBitSet<usize>,
     direction: Direction,
 }
 
 impl<'g, I: Idx, N, E> DepthFirstTraversal<'g, I, N, E> {
     pub fn with_start_node(
-        graph: &'g FrozenLinkedGraph<I, N, E>,
+        graph: &'g LinkedGraph<I, N, E>,
         start_node: I,
         direction: Direction,
     ) -> Self {
diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs b/compiler/rustc_data_structures/src/graph/linked_graph/tests.rs
@@ -1,9 +1,9 @@
 use rustc_index::Idx;
 use tracing::debug;
 
-use super::{Debug, FrozenLinkedGraph, LinkedGraph};
+use super::{Debug, LinkedGraph};
 
-type TestGraph = FrozenLinkedGraph<usize, &'static str, &'static str>;
+type TestGraph = LinkedGraph<usize, &'static str, &'static str>;
 
 fn create_graph() -> TestGraph {
     let mut graph = LinkedGraph::new();
@@ -38,7 +38,7 @@ fn create_graph() -> TestGraph {
     graph.add_edge(e, c, "EC");
     graph.add_edge(f, b, "FB");
 
-    return graph.freeze();
+    graph
 }
 
 #[test]
@@ -63,7 +63,7 @@ fn each_edge() {
 }
 
 fn test_adjacent_edges<I: Idx, N: PartialEq + Debug, E: PartialEq + Debug>(
-    graph: &FrozenLinkedGraph<I, N, E>,
+    graph: &LinkedGraph<I, N, E>,
     start_index: I,
     start_data: N,
     expected_incoming: &[(E, N)],
diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs
@@ -43,8 +43,7 @@ use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_index::IndexVec;
 use rustc_middle::dep_graph::{
-    DepGraphQuery, DepKind, DepNode, DepNodeExt, DepNodeFilter, DepNodeIndex, EdgeFilter,
-    FrozenDepGraphQuery, dep_kinds,
+    DepGraphQuery, DepKind, DepNode, DepNodeExt, DepNodeFilter, DepNodeIndex, EdgeFilter, dep_kinds,
 };
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
@@ -210,7 +209,6 @@ fn check_paths<'tcx>(tcx: TyCtxt<'tcx>, if_this_changed: &Sources, then_this_wou
         return;
     }
     tcx.dep_graph.with_query(|query| {
-        let query = query.clone().freeze();
         for &(_, source_def_id, ref source_dep_node) in if_this_changed {
             let dependents = query.transitive_predecessors(source_dep_node);
             for &(target_span, ref target_pass, _, ref target_dep_node) in then_this_would_need {
@@ -231,20 +229,18 @@ fn check_paths<'tcx>(tcx: TyCtxt<'tcx>, if_this_changed: &Sources, then_this_wou
 fn dump_graph(query: &DepGraphQuery) {
     let path: String = env::var("RUST_DEP_GRAPH").unwrap_or_else(|_| "dep_graph".to_string());
 
-    let query = query.clone().freeze();
-
     let nodes = match env::var("RUST_DEP_GRAPH_FILTER") {
         Ok(string) => {
             // Expect one of: "-> target", "source -> target", or "source ->".
             let edge_filter =
                 EdgeFilter::new(&string).unwrap_or_else(|e| bug!("invalid filter: {}", e));
-            let sources = node_set(&query, &edge_filter.source);
-            let targets = node_set(&query, &edge_filter.target);
-            filter_nodes(&query, &sources, &targets)
+            let sources = node_set(query, &edge_filter.source);
+            let targets = node_set(query, &edge_filter.target);
+            filter_nodes(query, &sources, &targets)
         }
         Err(_) => query.nodes().into_iter().map(|n| n.kind).collect(),
     };
-    let edges = filter_edges(&query, &nodes);
+    let edges = filter_edges(query, &nodes);
 
     {
         // dump a .txt file with just the edges:
@@ -308,7 +304,7 @@ impl<'a> dot::Labeller<'a> for GraphvizDepGraph {
 // filter) or the set of nodes whose labels contain all of those
 // substrings.
 fn node_set<'q>(
-    query: &'q FrozenDepGraphQuery,
+    query: &'q DepGraphQuery,
     filter: &DepNodeFilter,
 ) -> Option<FxIndexSet<&'q DepNode>> {
     debug!("node_set(filter={:?})", filter);
@@ -321,7 +317,7 @@ fn node_set<'q>(
 }
 
 fn filter_nodes<'q>(
-    query: &'q FrozenDepGraphQuery,
+    query: &'q DepGraphQuery,
     sources: &Option<FxIndexSet<&'q DepNode>>,
     targets: &Option<FxIndexSet<&'q DepNode>>,
 ) -> FxIndexSet<DepKind> {
@@ -339,7 +335,7 @@ fn filter_nodes<'q>(
 }
 
 fn walk_nodes<'q>(
-    query: &'q FrozenDepGraphQuery,
+    query: &'q DepGraphQuery,
     starts: &FxIndexSet<&'q DepNode>,
     direction: Direction,
 ) -> FxIndexSet<DepKind> {
@@ -363,7 +359,7 @@ fn walk_nodes<'q>(
 }
 
 fn walk_between<'q>(
-    query: &'q FrozenDepGraphQuery,
+    query: &'q DepGraphQuery,
     sources: &FxIndexSet<&'q DepNode>,
     targets: &FxIndexSet<&'q DepNode>,
 ) -> FxIndexSet<DepKind> {
@@ -401,7 +397,7 @@ fn walk_between<'q>(
         .collect();
 
     fn recurse(
-        query: &FrozenDepGraphQuery,
+        query: &DepGraphQuery,
         node_states: &mut IndexVec<DepNodeIndex, State>,
         node: DepNodeIndex,
     ) -> bool {
@@ -437,10 +433,7 @@ fn walk_between<'q>(
     }
 }
 
-fn filter_edges(
-    query: &FrozenDepGraphQuery,
-    nodes: &FxIndexSet<DepKind>,
-) -> Vec<(DepKind, DepKind)> {
+fn filter_edges(query: &DepGraphQuery, nodes: &FxIndexSet<DepKind>) -> Vec<(DepKind, DepKind)> {
     let uniq: FxIndexSet<_> = query
         .edges()
         .into_iter()
diff --git a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
@@ -3,9 +3,7 @@
 use std::fmt;
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::graph::linked_graph::{
-    Direction, FrozenLinkedGraph, INCOMING, LinkedGraph, OUTGOING,
-};
+use rustc_data_structures::graph::linked_graph::{Direction, INCOMING, LinkedGraph, OUTGOING};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::unord::UnordSet;
 use rustc_index::{IndexSlice, IndexVec};
@@ -118,7 +116,7 @@ struct RegionAndOrigin<'tcx> {
     origin: SubregionOrigin<'tcx>,
 }
 
-type RegionGraph<'tcx> = FrozenLinkedGraph<RegionVid, (), Constraint<'tcx>>;
+type RegionGraph<'tcx> = LinkedGraph<RegionVid, (), Constraint<'tcx>>;
 
 struct LexicalResolver<'cx, 'tcx> {
     region_rels: &'cx RegionRelations<'cx, 'tcx>,
@@ -671,17 +669,15 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
 
     fn construct_graph(&self) -> RegionGraph<'tcx> {
         let num_vars = self.num_vars();
-        let mut graph = LinkedGraph::from_node_n((), num_vars);
+        let mut graph = LinkedGraph::from_node_n((), num_vars + 2);
 
         // Issue #30438: two distinct dummy nodes, one for incoming
         // edges (dummy_source) and another for outgoing edges
         // (dummy_sink). In `dummy -> a -> b -> dummy`, using one
         // dummy node leads one to think (erroneously) there exists a
         // path from `b` to `a`. Two dummy nodes sidesteps the issue.
         let dummy_source = RegionVid::from_usize(num_vars);
-        graph.add_node(dummy_source, ());
         let dummy_sink = RegionVid::from_usize(num_vars + 1);
-        graph.add_node(dummy_sink, ());
 
         for (c, _) in &self.data.constraints {
             match c.kind {
@@ -703,7 +699,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
             }
         }
 
-        graph.freeze()
+        graph
     }
 
     fn collect_error_for_expanding_node(
diff --git a/compiler/rustc_middle/src/dep_graph/mod.rs b/compiler/rustc_middle/src/dep_graph/mod.rs
@@ -12,8 +12,8 @@ pub use dep_node::{DepKind, DepNode, DepNodeExt, dep_kind_from_label, dep_kinds,
 pub(crate) use dep_node::{make_compile_codegen_unit, make_compile_mono_item, make_metadata};
 pub use rustc_query_system::dep_graph::debug::{DepNodeFilter, EdgeFilter};
 pub use rustc_query_system::dep_graph::{
-    DepContext, DepGraphQuery, DepNodeIndex, Deps, FrozenDepGraphQuery, SerializedDepGraph,
-    SerializedDepNodeIndex, TaskDepsRef, WorkProduct, WorkProductId, WorkProductMap, hash_result,
+    DepContext, DepGraphQuery, DepNodeIndex, Deps, SerializedDepGraph, SerializedDepNodeIndex,
+    TaskDepsRef, WorkProduct, WorkProductId, WorkProductMap, hash_result,
 };
 
 pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepsType>;
diff --git a/compiler/rustc_query_system/src/dep_graph/mod.rs b/compiler/rustc_query_system/src/dep_graph/mod.rs
@@ -10,7 +10,7 @@ use std::panic;
 pub use dep_node::{DepKind, DepKindVTable, DepNode, DepNodeParams, WorkProductId};
 pub(crate) use graph::DepGraphData;
 pub use graph::{DepGraph, DepNodeIndex, TaskDepsRef, WorkProduct, WorkProductMap, hash_result};
-pub use query::{DepGraphQuery, FrozenDepGraphQuery};
+pub use query::DepGraphQuery;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sync::DynSync;
 use rustc_session::Session;
diff --git a/compiler/rustc_query_system/src/dep_graph/query.rs b/compiler/rustc_query_system/src/dep_graph/query.rs
