simple impl of graph for mir

Author: scottcarr

src/librustc/mir/cache.rs

@@ -10,8 +10,6 @@
 
 use std::cell::{Ref, RefCell};
 use rustc_data_structures::indexed_vec::IndexVec;
-use rustc_data_structures::graph_algorithms::dominators::{Dominators, dominators};
-//use mir::mir_cfg::MirCfg;
 
 use mir::repr::{Mir, BasicBlock};
 
@@ -20,7 +18,6 @@ use rustc_serialize as serialize;
 #[derive(Clone)]
 pub struct Cache {
     predecessors: RefCell<Option<IndexVec<BasicBlock, Vec<BasicBlock>>>>,
-    //dominators: RefCell<Option<Dominators<Mir<'tcx>>>>,
 }
 
 
@@ -40,7 +37,6 @@ impl Cache {
     pub fn new() -> Self {
         Cache {
             predecessors: RefCell::new(None),
-            //dominators: RefCell::new(None),
         }
     }
 
@@ -56,16 +52,6 @@ impl Cache {
 
         Ref::map(self.predecessors.borrow(), |p| p.as_ref().unwrap())
     }
-
-    //pub fn dominators<'a>(&self, mir: &Mir<'a>) -> Ref<Dominators<Mir<'a>>> {
-    pub fn dominators<'a>(&self, mir: &Mir<'a>) -> Dominators<Mir<'a>> {
-        //if self.dominators.borrow().is_none() {
-        //    *self.dominators.borrow_mut() = Some(calculate_dominators(mir, self));
-        //}
-
-        //Ref::map(self.dominators.borrow(), |p| p.as_ref().unwrap())
-        dominators(mir)
-    }
 }
 
 fn calculate_predecessors(mir: &Mir) -> IndexVec<BasicBlock, Vec<BasicBlock>> {

src/librustc/mir/repr.rs

@@ -12,7 +12,7 @@ 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::dominators::Dominators;
+use rustc_data_structures::graph_algorithms::dominators::{Dominators, dominators};
 use rustc_data_structures::graph_algorithms::{Graph, GraphPredecessors, GraphSuccessors};
 use hir::def_id::DefId;
 use ty::subst::Substs;
@@ -151,7 +151,8 @@ impl<'tcx> Mir<'tcx> {
     #[inline]
     //pub fn dominators(&'tcx self) -> Ref<Dominators<Self>> {
     pub fn dominators(&self) -> Dominators<Self> {
-        self.cache.dominators(self)
+        //self.cache.dominators(self)
+        dominators(self)
     }
 }
 
@@ -1188,30 +1189,21 @@ impl<'tcx> Graph for Mir<'tcx> {
     fn predecessors<'graph>(&'graph self, node: Self::Node)
                             -> <Self as GraphPredecessors<'graph>>::Iter
     {
-        //self.predecessors_for(node).iter().cloned()
-        panic!("not implemented!");
+        self.predecessors_for(node).clone().into_iter()
     }
     fn successors<'graph>(&'graph self, node: Self::Node)
-                            -> <Self as GraphSuccessors<'graph>>::Iter
+                          -> <Self as GraphSuccessors<'graph>>::Iter
     {
-        //match self.basic_blocks[node].terminator {
-        //    Some(term) => {
-        //        term.successors().iter().cloned()
-        //    },
-        //    _ => vec![].iter().clone()
-        //}
-        panic!("not implemented!");
+        self.basic_blocks[node].terminator().successors().into_owned().into_iter()
     }
 }
 
 impl<'a, 'b> GraphPredecessors<'b> for Mir<'a> {
     type Item = BasicBlock;
-    //type Iter = std::slice::Iter<'b, BasicBlock>;
-    type Iter = iter::Cloned<std::slice::Iter<'b, BasicBlock>>;
+    type Iter = std::vec::IntoIter<BasicBlock>;
 }
 
 impl<'a, 'b>  GraphSuccessors<'b> for Mir<'a> {
     type Item = BasicBlock;
-    type Iter = iter::Cloned<std::slice::Iter<'b, BasicBlock>>;
-    //type Iter = std::slice::Iter<'b, BasicBlock>;
+    type Iter = std::vec::IntoIter<BasicBlock>;
 }

src/librustc_data_structures/graph_algorithms/mod.rs

@@ -9,6 +9,11 @@
 // except according to those terms.
 
 use super::indexed_vec::Idx;
+use core::marker::{PhantomData};
+pub use std::slice::Iter;
+use std::ops::{Index, IndexMut};
+use std::clone::Clone;
+use std;
 
 //pub mod bit_set;
 pub mod dominators;
@@ -24,15 +29,20 @@ mod test;
 pub trait Graph
     where Self: for<'graph> GraphPredecessors<'graph, Item=<Self as Graph>::Node>,
           Self: for<'graph> GraphSuccessors<'graph, Item=<Self as Graph>::Node>
+    //where Self: Sized
 {
     type Node: Idx;
 
     fn num_nodes(&self) -> usize;
     fn start_node(&self) -> Self::Node;
     fn predecessors<'graph>(&'graph self, node: Self::Node)
                             -> <Self as GraphPredecessors<'graph>>::Iter;
+                            // why is returning an iterator so complicated?
+                            //-> NodeVec<Self, Self::Node>;
     fn successors<'graph>(&'graph self, node: Self::Node)
                             -> <Self as GraphSuccessors<'graph>>::Iter;
+                            //-> NodeVec<Self, Self::Node>;
+                            //-> std::slice::Iter<'graph, Self::Node>;
 }
 
 pub trait GraphPredecessors<'graph> {
@@ -51,3 +61,80 @@ pub trait GraphSuccessors<'graph> {
 //    }
 //}
 
+//#[derive(Clone, Debug)]
+//pub struct NodeVec<G: Graph, T> {
+//    pub vec: Vec<T>,
+//    graph: PhantomData<G>,
+//}
+//
+//impl<G: Graph, T: Clone> NodeVec<G, T> {
+//    pub fn from_elem(graph: &G, default: &T) -> Self {
+//        NodeVec::from_fn(graph, |_| default.clone())
+//    }
+//
+//    pub fn from_elem_with_len(num_nodes: usize, default: &T) -> Self {
+//        NodeVec::from_fn_with_len(num_nodes, |_| default.clone())
+//    }
+//}
+//
+//impl<G: Graph, T: Default> NodeVec<G, T> {
+//    pub fn from_default(graph: &G) -> Self {
+//        NodeVec::from_fn(graph, |_| T::default())
+//    }
+//
+//    pub fn from_default_with_len(num_nodes: usize) -> Self {
+//        NodeVec::from_fn_with_len(num_nodes, |_| T::default())
+//    }
+//}
+//
+//impl<G: Graph, T> NodeVec<G, T> {
+//    pub fn from_vec(v: Vec<T>) -> Self 
+//        where T: Clone
+//    {
+//
+//        NodeVec {
+//            vec: v.clone(),
+//            graph: PhantomData,
+//        }
+//    }
+//
+//    pub fn from_fn<F>(graph: &G, f: F) -> Self
+//        where F: FnMut(G::Node) -> T
+//    {
+//        Self::from_fn_with_len(graph.num_nodes(), f)
+//    }
+//
+//    pub fn from_fn_with_len<F>(num_nodes: usize, f: F) -> Self
+//        where F: FnMut(G::Node) -> T
+//    {
+//        NodeVec {
+//            vec: (0..num_nodes).map(G::Node::new).map(f).collect(),
+//            graph: PhantomData,
+//        }
+//    }
+//
+//    pub fn iter(&self) -> Iter<T> {
+//        self.vec.iter()
+//    }
+//
+//    pub fn len(&self) -> usize {
+//        self.vec.len()
+//    }
+//}
+//
+//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.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.index();
+//        &mut self.vec[index]
+//    }
+//}
+