From 71d656edde5b2e588a129951beef1c5c7dbe35e7 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 14 Feb 2026 17:41:51 +0300
Subject: [PATCH] LinkedGraph: Use IndexVec instead of Vec in LinkedGraph nodes

---
 .../src/graph/linked_graph/mod.rs             | 35 ++++++++++++-------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
index ecb0095626b4..6d53b155e9a2 100644
--- a/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/linked_graph/mod.rs
@@ -23,6 +23,7 @@
 use std::fmt::Debug;
 
 use rustc_index::bit_set::DenseBitSet;
+use rustc_index::{Idx, IndexSlice, IndexVec};
 use tracing::debug;
 
 #[cfg(test)]
@@ -45,7 +46,7 @@
 /// and does not implement those traits, so it has its own implementations of a
 /// few basic graph algorithms.
 pub struct LinkedGraph<N, E> {
-    nodes: Vec<Node<N>>,
+    nodes: IndexVec<NodeIndex, Node<N>>,
     edges: Vec<Edge<E>>,
 }
 
@@ -62,7 +63,7 @@ pub struct Edge<E> {
     pub data: E,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct NodeIndex(pub usize);
 
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -87,19 +88,29 @@ pub fn node_id(self) -> usize {
     }
 }
 
+impl Idx for NodeIndex {
+    fn new(idx: usize) -> NodeIndex {
+        NodeIndex(idx)
+    }
+
+    fn index(self) -> usize {
+        self.0
+    }
+}
+
 impl<N: Debug, E: Debug> LinkedGraph<N, E> {
     pub fn new() -> Self {
-        Self { nodes: Vec::new(), edges: Vec::new() }
+        Self { nodes: IndexVec::new(), edges: Vec::new() }
     }
 
     pub fn with_capacity(nodes: usize, edges: usize) -> Self {
-        Self { nodes: Vec::with_capacity(nodes), edges: Vec::with_capacity(edges) }
+        Self { nodes: IndexVec::with_capacity(nodes), edges: Vec::with_capacity(edges) }
     }
 
     // # Simple accessors
 
     #[inline]
-    pub fn all_nodes(&self) -> &[Node<N>] {
+    pub fn all_nodes(&self) -> &IndexSlice<NodeIndex, Node<N>> {
         &self.nodes
     }
 
@@ -131,15 +142,15 @@ pub fn add_node(&mut self, data: N) -> NodeIndex {
     }
 
     pub fn mut_node_data(&mut self, idx: NodeIndex) -> &mut N {
-        &mut self.nodes[idx.0].data
+        &mut self.nodes[idx].data
     }
 
     pub fn node_data(&self, idx: NodeIndex) -> &N {
-        &self.nodes[idx.0].data
+        &self.nodes[idx].data
     }
 
     pub fn node(&self, idx: NodeIndex) -> &Node<N> {
-        &self.nodes[idx.0]
+        &self.nodes[idx]
     }
 
     // # Edge construction and queries
@@ -154,16 +165,16 @@ pub fn add_edge(&mut self, source: NodeIndex, target: NodeIndex, data: E) -> Edg
         let idx = self.next_edge_index();
 
         // read current first of the list of edges from each node
-        let source_first = self.nodes[source.0].first_edge[OUTGOING.repr];
-        let target_first = self.nodes[target.0].first_edge[INCOMING.repr];
+        let source_first = self.nodes[source].first_edge[OUTGOING.repr];
+        let target_first = self.nodes[target].first_edge[INCOMING.repr];
 
         // create the new edge, with the previous firsts from each node
         // as the next pointers
         self.edges.push(Edge { next_edge: [source_first, target_first], source, target, data });
 
         // adjust the firsts for each node target be the next object.
-        self.nodes[source.0].first_edge[OUTGOING.repr] = idx;
-        self.nodes[target.0].first_edge[INCOMING.repr] = idx;
+        self.nodes[source].first_edge[OUTGOING.repr] = idx;
+        self.nodes[target].first_edge[INCOMING.repr] = idx;
 
         idx
     }