Auto merge of #57070 - Zoxc:ser-graph, r=<try>

[do not merge] Revert "Convert SerializedDepGraph to be a struct-of-arrays"

Let's check if #49069 was actually helpful.

r? @michaelwoerister

Author: bors

src/librustc/dep_graph/graph.rs

@@ -506,10 +506,18 @@ impl DepGraph {
     }
 
     pub fn serialize(&self) -> SerializedDepGraph {
+        let mut fingerprints = self.fingerprints.borrow_mut();
         let current_dep_graph = self.data.as_ref().unwrap().current.borrow();
 
-        let fingerprints = self.fingerprints.borrow().clone().convert_index_type();
-        let nodes = current_dep_graph.nodes.clone().convert_index_type();
+        // Make sure we don't run out of bounds below.
+        if current_dep_graph.nodes.len() > fingerprints.len() {
+            fingerprints.resize(current_dep_graph.nodes.len(), Fingerprint::ZERO);
+        }
+
+        let nodes: IndexVec<_, (DepNode, Fingerprint)> =
+            current_dep_graph.nodes.iter_enumerated().map(|(idx, &dep_node)| {
+            (dep_node, fingerprints[idx])
+        }).collect();
 
         let total_edge_count: usize = current_dep_graph.edges.iter()
                                                              .map(|v| v.len())
@@ -533,7 +541,6 @@ impl DepGraph {
 
         SerializedDepGraph {
             nodes,
-            fingerprints,
             edge_list_indices,
             edge_list_data,
         }

src/librustc/dep_graph/prev.rs

@@ -23,7 +23,7 @@ impl PreviousDepGraph {
     pub fn new(data: SerializedDepGraph) -> PreviousDepGraph {
         let index: FxHashMap<_, _> = data.nodes
             .iter_enumerated()
-            .map(|(idx, &dep_node)| (dep_node, idx))
+            .map(|(idx, &(dep_node, _))| (dep_node, idx))
             .collect();
         PreviousDepGraph { data, index }
     }
@@ -41,7 +41,7 @@ impl PreviousDepGraph {
 
     #[inline]
     pub fn index_to_node(&self, dep_node_index: SerializedDepNodeIndex) -> DepNode {
-        self.data.nodes[dep_node_index]
+        self.data.nodes[dep_node_index].0
     }
 
     #[inline]
@@ -58,14 +58,14 @@ impl PreviousDepGraph {
     pub fn fingerprint_of(&self, dep_node: &DepNode) -> Option<Fingerprint> {
         self.index
             .get(dep_node)
-            .map(|&node_index| self.data.fingerprints[node_index])
+            .map(|&node_index| self.data.nodes[node_index].1)
     }
 
     #[inline]
     pub fn fingerprint_by_index(&self,
                                 dep_node_index: SerializedDepNodeIndex)
                                 -> Fingerprint {
-        self.data.fingerprints[dep_node_index]
+        self.data.nodes[dep_node_index].1
     }
 
     pub fn node_count(&self) -> usize {

src/librustc/dep_graph/serialized.rs

@@ -22,10 +22,7 @@ newtype_index! {
 #[derive(Debug, RustcEncodable, RustcDecodable, Default)]
 pub struct SerializedDepGraph {
     /// The set of all DepNodes in the graph
-    pub nodes: IndexVec<SerializedDepNodeIndex, DepNode>,
-    /// The set of all Fingerprints in the graph. Each Fingerprint corresponds to
-    /// the DepNode at the same index in the nodes vector.
-    pub fingerprints: IndexVec<SerializedDepNodeIndex, Fingerprint>,
+    pub nodes: IndexVec<SerializedDepNodeIndex, (DepNode, Fingerprint)>,
     /// For each DepNode, stores the list of edges originating from that
     /// DepNode. Encoded as a [start, end) pair indexing into edge_list_data,
     /// which holds the actual DepNodeIndices of the target nodes.

src/librustc_data_structures/indexed_vec.rs

@@ -665,13 +665,6 @@ impl<I: Idx, T> IndexVec<I, T> {
             (c1, c2)
         }
     }
-
-    pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T> {
-        IndexVec {
-            raw: self.raw,
-            _marker: PhantomData,
-        }
-    }
 }
 
 impl<I: Idx, T: Clone> IndexVec<I, T> {

src/librustc_incremental/persist/save.rs

@@ -164,7 +164,7 @@ fn encode_dep_graph(tcx: TyCtxt,
 
         let mut counts: FxHashMap<_, Stat> = FxHashMap::default();
 
-        for (i, &node) in serialized_graph.nodes.iter_enumerated() {
+        for (i, &(node, _)) in serialized_graph.nodes.iter_enumerated() {
             let stat = counts.entry(node.kind).or_insert(Stat {
                 kind: node.kind,
                 node_counter: 0,