isolate predecessor computation

The new `Predecessors` type computes a set of interesting targets and
their HIR predecessors, and discards everything in between.

Author: nikomatsakis

src/librustc_data_structures/bitvec.rs

@@ -22,6 +22,12 @@ impl BitVector {
         BitVector { data: vec![0; num_words] }
     }
 
+    pub fn clear(&mut self) {
+        for p in &mut self.data {
+            *p = 0;
+        }
+    }
+
     pub fn contains(&self, bit: usize) -> bool {
         let (word, mask) = word_mask(bit);
         (self.data[word] & mask) != 0

src/librustc_data_structures/graph/mod.rs

@@ -296,12 +296,7 @@ impl<N: Debug, E: Debug> Graph<N, E> {
                               start: NodeIndex,
                               direction: Direction)
                               -> DepthFirstTraversal<'a, N, E> {
-        DepthFirstTraversal {
-            graph: self,
-            stack: vec![start],
-            visited: BitVector::new(self.nodes.len()),
-            direction: direction,
-        }
+        DepthFirstTraversal::with_start_node(self, start, direction)
     }
 }
 
@@ -378,26 +373,57 @@ pub struct DepthFirstTraversal<'g, N: 'g, E: 'g> {
     direction: Direction,
 }
 
+impl<'g, N: Debug, E: Debug> DepthFirstTraversal<'g, N, E> {
+    pub fn new(graph: &'g Graph<N, E>, direction: Direction) -> Self {
+        let visited = BitVector::new(graph.len_nodes());
+        DepthFirstTraversal {
+            graph: graph,
+            stack: vec![],
+            visited: visited,
+            direction: direction
+        }
+    }
+
+    pub fn with_start_node(graph: &'g Graph<N, E>,
+                           start_node: NodeIndex,
+                           direction: Direction)
+                           -> Self {
+        let mut visited = BitVector::new(graph.len_nodes());
+        visited.insert(start_node.node_id());
+        DepthFirstTraversal {
+            graph: graph,
+            stack: vec![start_node],
+            visited: visited,
+            direction: direction
+        }
+    }
+
+    pub fn reset(&mut self, start_node: NodeIndex) {
+        self.stack.truncate(0);
+        self.stack.push(start_node);
+        self.visited.clear();
+        self.visited.insert(start_node.node_id());
+    }
+
+    fn visit(&mut self, node: NodeIndex) {
+        if self.visited.insert(node.node_id()) {
+            self.stack.push(node);
+        }
+    }
+}
+
 impl<'g, N: Debug, E: Debug> Iterator for DepthFirstTraversal<'g, N, E> {
     type Item = NodeIndex;
 
     fn next(&mut self) -> Option<NodeIndex> {
-        while let Some(idx) = self.stack.pop() {
-            if !self.visited.insert(idx.node_id()) {
-                continue;
-            }
-
+        let next = self.stack.pop();
+        if let Some(idx) = next {
             for (_, edge) in self.graph.adjacent_edges(idx, self.direction) {
                 let target = edge.source_or_target(self.direction);
-                if !self.visited.contains(target.node_id()) {
-                    self.stack.push(target);
-                }
+                self.visit(target);
             }
-
-            return Some(idx);
         }
-
-        return None;
+        next
     }
 }
 

src/librustc_incremental/persist/hash.rs

@@ -39,6 +39,14 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> {
         }
     }
 
+    pub fn is_hashable(dep_node: &DepNode<DefId>) -> bool {
+        match *dep_node {
+            DepNode::Hir(_) => true,
+            DepNode::MetaData(def_id) => !def_id.is_local(),
+            _ => false,
+        }
+    }
+
     pub fn hash(&mut self, dep_node: &DepNode<DefId>) -> Option<(DefId, u64)> {
         match *dep_node {
             // HIR nodes (which always come from our crate) are an input:

src/librustc_incremental/persist/preds.rs

@@ -0,0 +1,63 @@
+use rustc::dep_graph::{DepGraphQuery, DepNode};
+use rustc::hir::def_id::DefId;
+use rustc_data_structures::fnv::FnvHashMap;
+use rustc_data_structures::graph::{DepthFirstTraversal, INCOMING, NodeIndex};
+
+use super::hash::*;
+
+/// A data-structure that makes it easy to enumerate the hashable
+/// predecessors of any given dep-node.
+pub struct Predecessors<'query> {
+    // - Keys: dep-nodes that may have work-products, output meta-data
+    //   nodes.
+    // - Values: transitive predecessors of the key that are hashable
+    //   (e.g., HIR nodes, input meta-data nodes)
+    pub inputs: FnvHashMap<&'query DepNode<DefId>, Vec<&'query DepNode<DefId>>>,
+
+    // - Keys: some hashable node
+    // - Values: the hash thereof
+    pub hashes: FnvHashMap<&'query DepNode<DefId>, u64>,
+}
+
+impl<'q> Predecessors<'q> {
+    pub fn new(query: &'q DepGraphQuery<DefId>, hcx: &mut HashContext) -> Self {
+        // Find nodes for which we want to know the full set of preds
+        let mut dfs = DepthFirstTraversal::new(&query.graph, INCOMING);
+        let all_nodes = query.graph.all_nodes();
+        let tcx = hcx.tcx;
+
+        let inputs: FnvHashMap<_, _> = all_nodes.iter()
+            .enumerate()
+            .filter(|&(_, node)| match node.data {
+                DepNode::WorkProduct(_) => true,
+                DepNode::MetaData(ref def_id) => def_id.is_local(),
+
+                // if -Z query-dep-graph is passed, save more extended data
+                // to enable better unit testing
+                DepNode::TypeckItemBody(_) |
+                DepNode::TransCrateItem(_) => tcx.sess.opts.debugging_opts.query_dep_graph,
+
+                _ => false,
+            })
+            .map(|(node_index, node)| {
+                dfs.reset(NodeIndex(node_index));
+                let inputs: Vec<_> = dfs.by_ref()
+                    .map(|i| &all_nodes[i.node_id()].data)
+                    .filter(|d| HashContext::is_hashable(d))
+                    .collect();
+                (&node.data, inputs)
+            })
+            .collect();
+
+        let mut hashes = FnvHashMap();
+        for input in inputs.values().flat_map(|v| v.iter().cloned()) {
+            hashes.entry(input)
+                  .or_insert_with(|| hcx.hash(input).unwrap().1);
+        }
+
+        Predecessors {
+            inputs: inputs,
+            hashes: hashes,
+        }
+    }
+}