replace NodeIndex with Idx in graph_algorithms

Author: scottcarr

src/librustc/mir/repr.rs

@@ -12,7 +12,6 @@ use graphviz::IntoCow;
 use middle::const_val::ConstVal;
 use rustc_const_math::{ConstUsize, ConstInt, ConstMathErr};
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
-use rustc_data_structures::graph_algorithms::NodeIndex;
 use hir::def_id::DefId;
 use ty::subst::Substs;
 use ty::{self, AdtDef, ClosureSubsts, FnOutput, Region, Ty};
@@ -175,12 +174,6 @@ impl Into<usize> for BasicBlock {
     }
 }
 
-impl NodeIndex for BasicBlock {
-    fn as_usize(self) -> usize {
-        self.index()
-    }
-}
-
 /// Grouped information about the source code origin of a MIR entity.
 /// Intended to be inspected by diagnostics and debuginfo.
 /// Most passes can work with it as a whole, within a single function.

src/librustc_data_structures/graph_algorithms/dominators/mod.rs

@@ -17,6 +17,7 @@
 use super::Graph;
 use super::iterate::reverse_post_order;
 use super::node_vec::NodeVec;
+use super::super::indexed_vec::Idx;
 
 use std::fmt;
 
@@ -162,7 +163,7 @@ impl<G: Graph> Dominators<G> {
             NodeVec::from_default_with_len(self.immediate_dominators.len());
         let mut root = None;
         for (index, immed_dom) in self.immediate_dominators.iter().enumerate() {
-            let node = G::Node::from(index);
+            let node = G::Node::new(index);
             match *immed_dom {
                 None => { /* node not reachable */ }
                 Some(immed_dom) => {

src/librustc_data_structures/graph_algorithms/mod.rs

@@ -7,8 +7,8 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use std::fmt::Debug;
-use std::hash::Hash;
+
+use super::indexed_vec::Idx;
 
 //pub mod bit_set;
 pub mod dominators;
@@ -25,7 +25,7 @@ pub trait Graph
     where Self: for<'graph> GraphPredecessors<'graph, Item=<Self as Graph>::Node>,
           Self: for<'graph> GraphSuccessors<'graph, Item=<Self as Graph>::Node>
 {
-    type Node: NodeIndex;
+    type Node: Idx;
 
     fn num_nodes(&self) -> usize;
     fn start_node(&self) -> Self::Node;
@@ -45,9 +45,9 @@ pub trait GraphSuccessors<'graph> {
     type Iter: Iterator<Item=Self::Item>;
 }
 
-pub trait NodeIndex: Copy + Debug + Eq + Ord + Hash + Into<usize> + From<usize> {
-    fn as_usize(self) -> usize {
-        self.into()
-    }
-}
+//pub trait NodeIndex: Copy + Debug + Eq + Ord + Hash + Into<usize> + From<usize> {
+//    fn as_usize(self) -> usize {
+//        self.into()
+//    }
+//}
 

src/librustc_data_structures/graph_algorithms/node_vec.rs

@@ -14,6 +14,7 @@ use std::ops::{Index, IndexMut};
 pub use std::slice::Iter;
 
 use super::Graph;
+use super::super::indexed_vec::Idx;
 
 #[derive(Clone, Debug)]
 pub struct NodeVec<G: Graph, T> {
@@ -52,7 +53,7 @@ impl<G: Graph, T> NodeVec<G, T> {
         where F: FnMut(G::Node) -> T
     {
         NodeVec {
-            vec: (0..num_nodes).map(G::Node::from).map(f).collect(),
+            vec: (0..num_nodes).map(G::Node::new).map(f).collect(),
             graph: PhantomData,
         }
     }
@@ -70,14 +71,14 @@ impl<G: Graph, T> Index<G::Node> for NodeVec<G, T> {
     type Output = T;
 
     fn index(&self, index: G::Node) -> &T {
-        let index: usize = index.into();
+        let index: usize = index.index();
         &self.vec[index]
     }
 }
 
 impl<G: Graph, T> IndexMut<G::Node> for NodeVec<G, T> {
     fn index_mut(&mut self, index: G::Node) -> &mut T {
-        let index: usize = index.into();
+        let index: usize = index.index();
         &mut self.vec[index]
     }
 }

src/librustc_data_structures/graph_algorithms/reachable/mod.rs

@@ -11,10 +11,10 @@
 //! Compute reachability using a simple dataflow propagation.
 //! Store end-result in a big NxN bit matrix.
 
-use super::{Graph, NodeIndex};
-//use super::bit_set::BitSet;
+use super::Graph;
 use super::super::bitvec::BitVector;
 use super::iterate::reverse_post_order;
+use super::super::indexed_vec::Idx;
 
 #[cfg(test)]
 mod test;
@@ -35,12 +35,12 @@ pub fn reachable_given_rpo<G: Graph>(graph: &G,
         for &node in reverse_post_order.iter().rev() {
             // every node can reach itself
             //changed |= reachability.bits.insert(node, node.as_usize());
-            changed |= reachability.bits[node.as_usize()].insert(node.as_usize());
+            changed |= reachability.bits[node.index()].insert(node.index());
 
             // and every pred can reach everything node can reach
             for pred in graph.predecessors(node) {
                 //changed |= reachability.bits.insert_bits_from(node, pred);
-                changed |= reachability.bits[node.as_usize()].insert(pred.as_usize());
+                changed |= reachability.bits[node.index()].insert(pred.index());
             }
         }
     }
@@ -58,14 +58,12 @@ impl Reachability {
     fn new<G: Graph>(graph: &G) -> Self {
         let num_nodes = graph.num_nodes();
         Reachability {
-            //bits: BitSet::new(graph, num_nodes),
             bits: vec![BitVector::new(num_nodes)],
         }
     }
 
     pub fn can_reach<G: Graph>(&self, source: G::Node, target: G::Node) -> bool {
-        let bit: usize = target.into();
-        //self.bits.is_set(source, bit)
-        self.bits[source.as_usize()].contains(bit)
+        let bit: usize = target.index();
+        self.bits[source.index()].contains(bit)
     }
 }

src/librustc_data_structures/indexed_vec.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::fmt::Debug;
 use std::iter::{self, FromIterator};
 use std::slice;
 use std::marker::PhantomData;
@@ -20,7 +21,7 @@ use rustc_serialize as serialize;
 /// Represents some newtyped `usize` wrapper.
 ///
 /// (purpose: avoid mixing indexes for different bitvector domains.)
-pub trait Idx: Copy + 'static {
+pub trait Idx: Copy + 'static + Eq + Debug {
     fn new(usize) -> Self;
     fn index(self) -> usize;
 }