apply rustfmt to librustc_data_structures, correcting rust-lang-nursery/rustfmt#836

src/librustc_data_structures/bitvec.rs

@@ -10,7 +10,7 @@
 
 /// A very simple BitVector type.
 pub struct BitVector {
-    data: Vec<u64>
+    data: Vec<u64>,
 }
 
 impl BitVector {
@@ -40,7 +40,9 @@ impl BitVector {
         for (i, j) in self.data.iter_mut().zip(&all.data) {
             let value = *i;
             *i = value | *j;
-            if value != *i { changed = true; }
+            if value != *i {
+                changed = true;
+            }
         }
         changed
     }
@@ -56,7 +58,7 @@ impl BitVector {
         BitVectorIter {
             iter: self.data.iter(),
             current: 0,
-            idx: 0
+            idx: 0,
         }
     }
 }
@@ -64,7 +66,7 @@ impl BitVector {
 pub struct BitVectorIter<'a> {
     iter: ::std::slice::Iter<'a, u64>,
     current: u64,
-    idx: usize
+    idx: usize,
 }
 
 impl<'a> Iterator for BitVectorIter<'a> {
@@ -108,7 +110,7 @@ impl BitMatrix {
         let u64s_per_elem = u64s(elements);
         BitMatrix {
             elements: elements,
-            vector: vec![0; elements * u64s_per_elem]
+            vector: vec![0; elements * u64s_per_elem],
         }
     }
 
@@ -150,8 +152,12 @@ impl BitMatrix {
         for (base, (i, j)) in (a_start..a_end).zip(b_start..b_end).enumerate() {
             let mut v = self.vector[i] & self.vector[j];
             for bit in 0..64 {
-                if v == 0 { break; }
+                if v == 0 {
-                if v & 0x1 != 0 { result.push(base*64 + bit); }
+                    break;
+                }
+                if v & 0x1 != 0 {
+                    result.push(base * 64 + bit);
+                }
                 v >>= 1;
             }
         }
@@ -170,9 +176,7 @@ impl BitMatrix {
         let (write_start, write_end) = self.range(write);
         let vector = &mut self.vector[..];
         let mut changed = false;
-        for (read_index, write_index) in
+        for (read_index, write_index) in (read_start..read_end).zip(write_start..write_end) {
-            (read_start..read_end).zip(write_start..write_end)
-        {
             let v1 = vector[write_index];
             let v2 = v1 | vector[read_index];
             vector[write_index] = v2;
@@ -204,7 +208,8 @@ fn bitvec_iter_works() {
     bitvec.insert(65);
     bitvec.insert(66);
     bitvec.insert(99);
-    assert_eq!(bitvec.iter().collect::<Vec<_>>(), [1, 10, 19, 62, 63, 64, 65, 66, 99]);
+    assert_eq!(bitvec.iter().collect::<Vec<_>>(),
+               [1, 10, 19, 62, 63, 64, 65, 66, 99]);
 }
 
 #[test]
@@ -217,7 +222,8 @@ fn bitvec_iter_works_2() {
     bitvec.insert(66);
     bitvec.insert(99);
     bitvec.insert(299);
-    assert_eq!(bitvec.iter().collect::<Vec<_>>(), [1, 10, 19, 62, 66, 99, 299]);
+    assert_eq!(bitvec.iter().collect::<Vec<_>>(),
+               [1, 10, 19, 62, 66, 99, 299]);
 
 }
 

src/librustc_data_structures/fnv.rs

@@ -36,7 +36,9 @@ pub struct FnvHasher(u64);
 
 impl Default for FnvHasher {
     #[inline]
-    fn default() -> FnvHasher { FnvHasher(0xcbf29ce484222325) }
+    fn default() -> FnvHasher {
+        FnvHasher(0xcbf29ce484222325)
+    }
 }
 
 impl Hasher for FnvHasher {
@@ -51,5 +53,7 @@ impl Hasher for FnvHasher {
     }
 
     #[inline]
-    fn finish(&self) -> u64 { self.0 }
+    fn finish(&self) -> u64 {
+        self.0
+    }
 }

src/librustc_data_structures/graph/mod.rs

@@ -71,9 +71,13 @@ impl<N> SnapshotVecDelegate for Edge<N> {
 
 impl<E: Debug> Debug for Edge<E> {
     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
-        write!(f, "Edge {{ next_edge: [{:?}, {:?}], source: {:?}, target: {:?}, data: {:?} }}",
+        write!(f,
-               self.next_edge[0], self.next_edge[1], self.source,
+               "Edge {{ next_edge: [{:?}, {:?}], source: {:?}, target: {:?}, data: {:?} }}",
-               self.target, self.data)
+               self.next_edge[0],
+               self.next_edge[1],
+               self.source,
+               self.target,
+               self.data)
     }
 }
 
@@ -87,7 +91,9 @@ pub const INVALID_EDGE_INDEX: EdgeIndex = EdgeIndex(usize::MAX);
 
 // Use a private field here to guarantee no more instances are created:
 #[derive(Copy, Clone, Debug, PartialEq)]
-pub struct Direction { repr: usize }
+pub struct Direction {
+    repr: usize,
+}
 
 pub const OUTGOING: Direction = Direction { repr: 0 };
 
@@ -95,12 +101,16 @@ pub const INCOMING: Direction = Direction { repr: 1 };
 
 impl NodeIndex {
     /// Returns unique id (unique with respect to the graph holding associated node).
-    pub fn node_id(&self) -> usize { self.0 }
+    pub fn node_id(&self) -> usize {
+        self.0
+    }
 }
 
 impl EdgeIndex {
     /// Returns unique id (unique with respect to the graph holding associated edge).
-    pub fn edge_id(&self) -> usize { self.0 }
+    pub fn edge_id(&self) -> usize {
+        self.0
+    }
 }
 
 impl<N: Debug, E: Debug> Graph<N, E> {
@@ -145,7 +155,7 @@ impl<N:Debug,E:Debug> Graph<N,E> {
         let idx = self.next_node_index();
         self.nodes.push(Node {
             first_edge: [INVALID_EDGE_INDEX, INVALID_EDGE_INDEX],
-            data: data
+            data: data,
         });
         idx
     }
@@ -169,19 +179,14 @@ impl<N:Debug,E:Debug> Graph<N,E> {
         EdgeIndex(self.edges.len())
     }
 
-    pub fn add_edge(&mut self,
+    pub fn add_edge(&mut self, source: NodeIndex, target: NodeIndex, data: E) -> EdgeIndex {
-                    source: NodeIndex,
-                    target: NodeIndex,
-                    data: E) -> EdgeIndex {
         debug!("graph: add_edge({:?}, {:?}, {:?})", source, target, data);
 
         let idx = self.next_edge_index();
 
         // read current first of the list of edges from each node
-        let source_first = self.nodes[source.0]
+        let source_first = self.nodes[source.0].first_edge[OUTGOING.repr];
-                                     .first_edge[OUTGOING.repr];
+        let target_first = self.nodes[target.0].first_edge[INCOMING.repr];
-        let target_first = self.nodes[target.0]
-                                     .first_edge[INCOMING.repr];
 
         // create the new edge, with the previous firsts from each node
         // as the next pointers
@@ -189,7 +194,7 @@ impl<N:Debug,E:Debug> Graph<N,E> {
             next_edge: [source_first, target_first],
             source: source,
             target: target,
-            data: data
+            data: data,
         });
 
         // adjust the firsts for each node target be the next object.
@@ -230,15 +235,15 @@ impl<N:Debug,E:Debug> Graph<N,E> {
     ///////////////////////////////////////////////////////////////////////////
     // Iterating over nodes, edges
 
-    pub fn each_node<'a, F>(&'a self, mut f: F) -> bool where
+    pub fn each_node<'a, F>(&'a self, mut f: F) -> bool
-        F: FnMut(NodeIndex, &'a Node<N>) -> bool,
+        where F: FnMut(NodeIndex, &'a Node<N>) -> bool
     {
         //! Iterates over all edges defined in the graph.
         self.nodes.iter().enumerate().all(|(i, node)| f(NodeIndex(i), node))
     }
 
-    pub fn each_edge<'a, F>(&'a self, mut f: F) -> bool where
+    pub fn each_edge<'a, F>(&'a self, mut f: F) -> bool
-        F: FnMut(EdgeIndex, &'a Edge<E>) -> bool,
+        where F: FnMut(EdgeIndex, &'a Edge<E>) -> bool
     {
         //! Iterates over all edges defined in the graph
         self.edges.iter().enumerate().all(|(i, edge)| f(EdgeIndex(i), edge))
@@ -254,7 +259,11 @@ impl<N:Debug,E:Debug> Graph<N,E> {
 
     pub fn adjacent_edges(&self, source: NodeIndex, direction: Direction) -> AdjacentEdges<N, E> {
         let first_edge = self.node(source).first_edge[direction.repr];
-        AdjacentEdges { graph: self, direction: direction, next: first_edge }
+        AdjacentEdges {
+            graph: self,
+            direction: direction,
+            next: first_edge,
+        }
     }
 
     pub fn successor_nodes(&self, source: NodeIndex) -> AdjacentTargets<N, E> {
@@ -274,8 +283,8 @@ impl<N:Debug,E:Debug> Graph<N,E> {
     // variables or other bitsets. This method facilitates such a
     // computation.
 
-    pub fn iterate_until_fixed_point<'a, F>(&'a self, mut op: F) where
+    pub fn iterate_until_fixed_point<'a, F>(&'a self, mut op: F)
-        F: FnMut(usize, EdgeIndex, &'a Edge<E>) -> bool,
+        where F: FnMut(usize, EdgeIndex, &'a Edge<E>) -> bool
     {
         let mut iteration = 0;
         let mut changed = true;
@@ -301,7 +310,8 @@ impl<N:Debug,E:Debug> Graph<N,E> {
 // Iterators
 
 pub struct AdjacentEdges<'g, N, E>
-    where N:'g, E:'g
+    where N: 'g,
+          E: 'g
 {
     graph: &'g Graph<N, E>,
     direction: Direction,
@@ -334,7 +344,8 @@ impl<'g, N:Debug, E:Debug> Iterator for AdjacentEdges<'g, N, E> {
 }
 
 pub struct AdjacentTargets<'g, N: 'g, E: 'g>
-    where N:'g, E:'g
+    where N: 'g,
+          E: 'g
 {
     edges: AdjacentEdges<'g, N, E>,
 }
@@ -348,7 +359,8 @@ impl<'g, N:Debug, E:Debug> Iterator for AdjacentTargets<'g, N, E> {
 }
 
 pub struct AdjacentSources<'g, N: 'g, E: 'g>
-    where N:'g, E:'g
+    where N: 'g,
+          E: 'g
 {
     edges: AdjacentEdges<'g, N, E>,
 }
@@ -364,7 +376,7 @@ impl<'g, N:Debug, E:Debug> Iterator for AdjacentSources<'g, N, E> {
 pub struct DepthFirstTraversal<'g, N: 'g, E: 'g> {
     graph: &'g Graph<N, E>,
     stack: Vec<NodeIndex>,
-    visited: BitVector
+    visited: BitVector,
 }
 
 impl<'g, N: Debug, E: Debug> Iterator for DepthFirstTraversal<'g, N, E> {
@@ -389,8 +401,8 @@ impl<'g, N:Debug, E:Debug> Iterator for DepthFirstTraversal<'g, N, E> {
     }
 }
 
-pub fn each_edge_index<F>(max_edge_index: EdgeIndex, mut f: F) where
+pub fn each_edge_index<F>(max_edge_index: EdgeIndex, mut f: F)
-    F: FnMut(EdgeIndex) -> bool,
+    where F: FnMut(EdgeIndex) -> bool
 {
     let mut i = 0;
     let n = max_edge_index.0;

src/librustc_data_structures/graph/tests.rs

@@ -76,7 +76,10 @@ fn test_adjacent_edges<N:PartialEq+Debug,E:PartialEq+Debug>(graph: &Graph<N,E>,
         assert!(graph.edge_data(edge_index) == &edge.data);
         assert!(counter < expected_incoming.len());
         debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
-               counter, expected_incoming[counter], edge_index, edge);
+               counter,
+               expected_incoming[counter],
+               edge_index,
+               edge);
         match expected_incoming[counter] {
             (ref e, ref n) => {
                 assert!(e == &edge.data);
@@ -93,7 +96,10 @@ fn test_adjacent_edges<N:PartialEq+Debug,E:PartialEq+Debug>(graph: &Graph<N,E>,
         assert!(graph.edge_data(edge_index) == &edge.data);
         assert!(counter < expected_outgoing.len());
         debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
-               counter, expected_outgoing[counter], edge_index, edge);
+               counter,
+               expected_outgoing[counter],
+               edge_index,
+               edge);
         match expected_outgoing[counter] {
             (ref e, ref n) => {
                 assert!(e == &edge.data);
@@ -109,31 +115,27 @@ fn test_adjacent_edges<N:PartialEq+Debug,E:PartialEq+Debug>(graph: &Graph<N,E>,
 #[test]
 fn each_adjacent_from_a() {
     let graph = create_graph();
-    test_adjacent_edges(&graph, NodeIndex(0), "A",
+    test_adjacent_edges(&graph, NodeIndex(0), "A", &[], &[("AB", "B")]);
-                        &[],
-                        &[("AB", "B")]);
 }
 
 #[test]
 fn each_adjacent_from_b() {
     let graph = create_graph();
-    test_adjacent_edges(&graph, NodeIndex(1), "B",
+    test_adjacent_edges(&graph,
-                        &[("FB", "F"), ("AB", "A"),],
+                        NodeIndex(1),
-                        &[("BD", "D"), ("BC", "C"),]);
+                        "B",
+                        &[("FB", "F"), ("AB", "A")],
+                        &[("BD", "D"), ("BC", "C")]);
 }
 
 #[test]
 fn each_adjacent_from_c() {
     let graph = create_graph();
-    test_adjacent_edges(&graph, NodeIndex(2), "C",
+    test_adjacent_edges(&graph, NodeIndex(2), "C", &[("EC", "E"), ("BC", "B")], &[]);
-                        &[("EC", "E"), ("BC", "B")],
-                        &[]);
 }
 
 #[test]
 fn each_adjacent_from_d() {
     let graph = create_graph();
-    test_adjacent_edges(&graph, NodeIndex(3), "D",
+    test_adjacent_edges(&graph, NodeIndex(3), "D", &[("BD", "B")], &[("DE", "E")]);
-                        &[("BD", "B")],
-                        &[("DE", "E")]);
 }

src/librustc_data_structures/ivar.rs

@@ -26,14 +26,12 @@ use std::cell::Cell;
 /// suffices for the current purposes.
 #[derive(PartialEq)]
 pub struct Ivar<T: Copy> {
-    data: Cell<Option<T>>
+    data: Cell<Option<T>>,
 }
 
 impl<T: Copy> Ivar<T> {
     pub fn new() -> Ivar<T> {
-        Ivar {
+        Ivar { data: Cell::new(None) }
-            data: Cell::new(None)
-        }
     }
 
     pub fn get(&self) -> Option<T> {
@@ -41,8 +39,7 @@ impl<T: Copy> Ivar<T> {
     }
 
     pub fn fulfill(&self, value: T) {
-        assert!(self.data.get().is_none(),
+        assert!(self.data.get().is_none(), "Value already set!");
-                "Value already set!");
         self.data.set(Some(value));
     }
 
@@ -59,7 +56,7 @@ impl<T: Copy+fmt::Debug> fmt::Debug for Ivar<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.get() {
             Some(val) => write!(f, "Ivar({:?})", val),
-            None => f.write_str("Ivar(<unfulfilled>)")
+            None => f.write_str("Ivar(<unfulfilled>)"),
         }
     }
 }
@@ -68,7 +65,7 @@ impl<T: Copy> Clone for Ivar<T> {
     fn clone(&self) -> Ivar<T> {
         match self.get() {
             Some(val) => Ivar { data: Cell::new(Some(val)) },
-            None => Ivar::new()
+            None => Ivar::new(),
         }
     }
 }

src/librustc_data_structures/lib.rs

@@ -32,7 +32,8 @@
 #![cfg_attr(test, feature(test))]
 
 extern crate core;
-#[macro_use] extern crate log;
+#[macro_use]
+extern crate log;
 extern crate serialize as rustc_serialize; // used by deriving
 
 pub mod bitvec;

src/librustc_data_structures/obligation_forest/mod.rs

@@ -43,7 +43,7 @@ pub struct ObligationForest<O,T> {
     /// backtrace iterator (which uses `split_at`).
     nodes: Vec<Node<O>>,
     trees: Vec<Tree<T>>,
-    snapshots: Vec<usize>
+    snapshots: Vec<usize>,
 }
 
 pub struct Snapshot {
@@ -67,7 +67,9 @@ struct Node<O> {
 #[derive(Debug)]
 enum NodeState<O> {
     /// Obligation not yet resolved to success or error.
-    Pending { obligation: O },
+    Pending {
+        obligation: O,
+    },
 
     /// Obligation resolved to success; `num_incomplete_children`
     /// indicates the number of children still in an "incomplete"
@@ -77,7 +79,10 @@ enum NodeState<O> {
     ///
     /// Once all children have completed, success nodes are removed
     /// from the vector by the compression step.
-    Success { obligation: O, num_incomplete_children: usize },
+    Success {
+        obligation: O,
+        num_incomplete_children: usize,
+    },
 
     /// This obligation was resolved to an error. Error nodes are
     /// removed from the vector by the compression step.
@@ -113,7 +118,7 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
         ObligationForest {
             trees: vec![],
             nodes: vec![],
-            snapshots: vec![]
+            snapshots: vec![],
         }
     }
 
@@ -148,11 +153,12 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
         // snapshot but pushing trees, all nodes after that should be
         // roots of other trees as well
         let first_root_index = self.trees[trees_len].root.get();
-        debug_assert!(
+        debug_assert!(self.nodes[first_root_index..]
-            self.nodes[first_root_index..]
                           .iter()
                           .zip(first_root_index..)
-                .all(|(root, root_index)| self.trees[root.tree.get()].root.get() == root_index));
+                          .all(|(root, root_index)| {
+                              self.trees[root.tree.get()].root.get() == root_index
+                          }));
 
         // Pop off tree/root pairs pushed during snapshot.
         self.trees.truncate(trees_len);
@@ -169,7 +175,10 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
     pub fn push_tree(&mut self, obligation: O, tree_state: T) {
         let index = NodeIndex::new(self.nodes.len());
         let tree = TreeIndex::new(self.trees.len());
-        self.trees.push(Tree { root: index, state: tree_state });
+        self.trees.push(Tree {
+            root: index,
+            state: tree_state,
+        });
         self.nodes.push(Node::new(tree, None, obligation));
     }
 
@@ -184,7 +193,10 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
             self.inherit_error(index);
             if let NodeState::Pending { .. } = self.nodes[index].state {
                 let backtrace = self.backtrace(index);
-                errors.push(Error { error: error.clone(), backtrace: backtrace });
+                errors.push(Error {
+                    error: error.clone(),
+                    backtrace: backtrace,
+                });
             }
         }
         let successful_obligations = self.compress();
@@ -193,11 +205,16 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
     }
 
     /// Returns the set of obligations that are in a pending state.
-    pub fn pending_obligations(&self) -> Vec<O> where O: Clone {
+    pub fn pending_obligations(&self) -> Vec<O>
-        self.nodes.iter()
+        where O: Clone
-                  .filter_map(|n| match n.state {
+    {
+        self.nodes
+            .iter()
+            .filter_map(|n| {
+                match n.state {
                     NodeState::Pending { ref obligation } => Some(obligation),
                     _ => None,
+                }
             })
             .cloned()
             .collect()
@@ -207,7 +224,8 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
     ///
     /// This CANNOT be unrolled (presently, at least).
     pub fn process_obligations<E, F>(&mut self, mut action: F) -> Outcome<O, E>
-        where E: Debug, F: FnMut(&mut O, &mut T, Backtrace<O>) -> Result<Option<Vec<O>>, E>
+        where E: Debug,
+              F: FnMut(&mut O, &mut T, Backtrace<O>) -> Result<Option<Vec<O>>, E>
     {
         debug!("process_obligations(len={})", self.nodes.len());
         assert!(!self.in_snapshot()); // cannot unroll this action
@@ -228,7 +246,8 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
             self.inherit_error(index);
 
             debug!("process_obligations: node {} == {:?}",
-                   index, self.nodes[index].state);
+                   index,
+                   self.nodes[index].state);
 
             let result = {
                 let Node { tree, parent, .. } = self.nodes[index];
@@ -236,14 +255,16 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
                 let backtrace = Backtrace::new(prefix, parent);
                 match suffix[0].state {
                     NodeState::Error |
-                    NodeState::Success { .. } =>
+                    NodeState::Success { .. } => continue,
-                        continue,
+                    NodeState::Pending { ref mut obligation } => {
-                    NodeState::Pending { ref mut obligation } =>
+                        action(obligation, &mut self.trees[tree.get()].state, backtrace)
-                        action(obligation, &mut self.trees[tree.get()].state, backtrace),
+                    }
                 }
             };
 
-            debug!("process_obligations: node {} got result {:?}", index, result);
+            debug!("process_obligations: node {} got result {:?}",
+                   index,
+                   result);
 
             match result {
                 Ok(None) => {
@@ -256,7 +277,10 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
                 }
                 Err(err) => {
                     let backtrace = self.backtrace(index);
-                    errors.push(Error { error: err, backtrace: backtrace });
+                    errors.push(Error {
+                        error: err,
+                        backtrace: backtrace,
+                    });
                 }
             }
         }
@@ -291,20 +315,21 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
             // create child work
             let tree_index = self.nodes[index].tree;
             let node_index = NodeIndex::new(index);
-            self.nodes.extend(
+            self.nodes.extend(children.into_iter()
-                children.into_iter()
                                       .map(|o| Node::new(tree_index, Some(node_index), o)));
         }
 
         // change state from `Pending` to `Success`, temporarily swapping in `Error`
         let state = mem::replace(&mut self.nodes[index].state, NodeState::Error);
         self.nodes[index].state = match state {
-            NodeState::Pending { obligation } =>
+            NodeState::Pending { obligation } => {
-                NodeState::Success { obligation: obligation,
+                NodeState::Success {
-                                     num_incomplete_children: num_incomplete_children },
+                    obligation: obligation,
+                    num_incomplete_children: num_incomplete_children,
+                }
+            }
             NodeState::Success { .. } |
-            NodeState::Error =>
+            NodeState::Error => unreachable!(),
-                unreachable!()
         };
     }
 
@@ -358,14 +383,19 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
                     // there was an error in the ancestors, it should
                     // have been propagated down and we should never
                     // have tried to process this obligation
-                    panic!("encountered error in node {:?} when collecting stack trace", p);
+                    panic!("encountered error in node {:?} when collecting stack trace",
+                           p);
                 }
             }
 
             // loop to the parent
             match self.nodes[p].parent {
-                Some(q) => { p = q.get(); }
+                Some(q) => {
-                None => { return trace; }
+                    p = q.get();
+                }
+                None => {
+                    return trace;
+                }
             }
         }
     }
@@ -427,16 +457,17 @@ impl<O: Debug, T: Debug> ObligationForest<O, T> {
 
         // Pop off all the nodes we killed and extract the success
         // stories.
-        let successful =
+        let successful = (0..dead_nodes)
-            (0 .. dead_nodes)
                              .map(|_| self.nodes.pop().unwrap())
-            .flat_map(|node| match node.state {
+                             .flat_map(|node| {
+                                 match node.state {
                                      NodeState::Error => None,
                                      NodeState::Pending { .. } => unreachable!(),
                                      NodeState::Success { obligation, num_incomplete_children } => {
                                          assert_eq!(num_incomplete_children, 0);
                                          Some(obligation)
                                      }
+                                 }
                              })
                              .collect();
 
@@ -484,7 +515,10 @@ pub struct Backtrace<'b, O: 'b> {
 
 impl<'b, O> Backtrace<'b, O> {
     fn new(nodes: &'b [Node<O>], pointer: Option<NodeIndex>) -> Backtrace<'b, O> {
-        Backtrace { nodes: nodes, pointer: pointer }
+        Backtrace {
+            nodes: nodes,
+            pointer: pointer,
+        }
     }
 }
 
@@ -497,9 +531,7 @@ impl<'b, O> Iterator for Backtrace<'b, O> {
             self.pointer = self.nodes[p.get()].parent;
             match self.nodes[p.get()].state {
                 NodeState::Pending { ref obligation } |
-                NodeState::Success { ref obligation, .. } => {
+                NodeState::Success { ref obligation, .. } => Some(obligation),
-                    Some(obligation)
-                }
                 NodeState::Error => {
                     panic!("Backtrace encountered an error.");
                 }

src/librustc_data_structures/obligation_forest/node_index.rs

@@ -13,19 +13,16 @@ use std::u32;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct NodeIndex {
-    index: NonZero<u32>
+    index: NonZero<u32>,
 }
 
 impl NodeIndex {
     pub fn new(value: usize) -> NodeIndex {
         assert!(value < (u32::MAX as usize));
-        unsafe {
+        unsafe { NodeIndex { index: NonZero::new((value as u32) + 1) } }
-            NodeIndex { index: NonZero::new((value as u32) + 1) }
-        }
     }
 
     pub fn get(self) -> usize {
         (*self.index - 1) as usize
     }
 }
-

src/librustc_data_structures/obligation_forest/test.rs

@@ -21,8 +21,9 @@ fn push_pop() {
     //      A |-> A.1
     //        |-> A.2
     //        |-> A.3
-    let Outcome { completed: ok, errors: err, .. } =
+    let Outcome { completed: ok, errors: err, .. } = forest.process_obligations(|obligation,
-        forest.process_obligations(|obligation, tree, _| {
+                                                                                 tree,
+                                                                                 _| {
         assert_eq!(obligation.chars().next(), tree.chars().next());
         match *obligation {
             "A" => Ok(Some(vec!["A.1", "A.2", "A.3"])),
@@ -32,8 +33,11 @@ fn push_pop() {
         }
     });
     assert_eq!(ok, vec!["C"]);
-    assert_eq!(err, vec![Error {error: "B is for broken",
+    assert_eq!(err,
-                                backtrace: vec!["B"]}]);
+               vec![Error {
+                        error: "B is for broken",
+                        backtrace: vec!["B"],
+                    }]);
 
     // second round: two delays, one success, creating an uneven set of subtasks:
     //      A |-> A.1
@@ -61,8 +65,9 @@ fn push_pop() {
     // propagates to A.3.i, but not D.1 or D.2.
     //      D |-> D.1 |-> D.1.i
     //        |-> D.2 |-> D.2.i
-    let Outcome { completed: ok, errors: err, .. } =
+    let Outcome { completed: ok, errors: err, .. } = forest.process_obligations(|obligation,
-        forest.process_obligations(|obligation, tree, _| {
+                                                                                 tree,
+                                                                                 _| {
         assert_eq!(obligation.chars().next(), tree.chars().next());
         match *obligation {
             "A.1" => Ok(Some(vec![])),
@@ -73,12 +78,16 @@ fn push_pop() {
         }
     });
     assert_eq!(ok, vec!["A.1"]);
-    assert_eq!(err, vec![Error { error: "A is for apple",
+    assert_eq!(err,
-                                 backtrace: vec!["A.2", "A"] }]);
+               vec![Error {
+                        error: "A is for apple",
+                        backtrace: vec!["A.2", "A"],
+                    }]);
 
     // fourth round: error in D.1.i that should propagate to D.2.i
-    let Outcome { completed: ok, errors: err, .. } =
+    let Outcome { completed: ok, errors: err, .. } = forest.process_obligations(|obligation,
-        forest.process_obligations(|obligation, tree, _| {
+                                                                                 tree,
+                                                                                 _| {
         assert_eq!(obligation.chars().next(), tree.chars().next());
         match *obligation {
             "D.1.i" => Err("D is for dumb"),
@@ -86,8 +95,11 @@ fn push_pop() {
         }
     });
     assert_eq!(ok, Vec::<&'static str>::new());
-    assert_eq!(err, vec![Error { error: "D is for dumb",
+    assert_eq!(err,
-                                 backtrace: vec!["D.1.i", "D.1", "D"] }]);
+               vec![Error {
+                        error: "D is for dumb",
+                        backtrace: vec!["D.1.i", "D.1", "D"],
+                    }]);
 }
 
 // Test that if a tree with grandchildren succeeds, everything is
@@ -150,8 +162,11 @@ fn success_in_grandchildren() {
     assert_eq!(ok, vec!["A.2.i.a", "A.2.i", "A.2", "A"]);
     assert!(err.is_empty());
 
-    let Outcome { completed: ok, errors: err, .. } =
+    let Outcome { completed: ok, errors: err, .. } = forest.process_obligations::<(), _>(|_,
-        forest.process_obligations::<(),_>(|_, _, _| unreachable!());
+                                                                                          _,
+                                                                                          _| {
+        unreachable!()
+    });
     assert!(ok.is_empty());
     assert!(err.is_empty());
 }

src/librustc_data_structures/obligation_forest/tree_index.rs

@@ -12,7 +12,7 @@ use std::u32;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct TreeIndex {
-    index: u32
+    index: u32,
 }
 
 impl TreeIndex {
@@ -25,4 +25,3 @@ impl TreeIndex {
         self.index as usize
     }
 }
-

src/librustc_data_structures/snapshot_vec.rs

@@ -37,7 +37,7 @@ pub enum UndoLog<D:SnapshotVecDelegate> {
     SetElem(usize, D::Value),
 
     /// Extensible set of actions
-    Other(D::Undo)
+    Other(D::Undo),
 }
 
 pub struct SnapshotVec<D: SnapshotVecDelegate> {
@@ -117,9 +117,7 @@ impl<D:SnapshotVecDelegate> SnapshotVec<D> {
         Snapshot { length: length }
     }
 
-    pub fn actions_since_snapshot(&self,
+    pub fn actions_since_snapshot(&self, snapshot: &Snapshot) -> &[UndoLog<D>] {
-                                  snapshot: &Snapshot)
-                                  -> &[UndoLog<D>] {
         &self.undo_log[snapshot.length..]
     }
 
@@ -128,10 +126,9 @@ impl<D:SnapshotVecDelegate> SnapshotVec<D> {
         assert!(self.undo_log.len() > snapshot.length);
 
         // Invariant established by start_snapshot():
-        assert!(
+        assert!(match self.undo_log[snapshot.length] {
-            match self.undo_log[snapshot.length] {
             OpenSnapshot => true,
-                _ => false
+            _ => false,
         });
     }
 
@@ -168,7 +165,10 @@ impl<D:SnapshotVecDelegate> SnapshotVec<D> {
         }
 
         let v = self.undo_log.pop().unwrap();
-        assert!(match v { OpenSnapshot => true, _ => false });
+        assert!(match v {
+            OpenSnapshot => true,
+            _ => false,
+        });
         assert!(self.undo_log.len() == snapshot.length);
     }
 
@@ -190,18 +190,26 @@ impl<D:SnapshotVecDelegate> SnapshotVec<D> {
 
 impl<D: SnapshotVecDelegate> ops::Deref for SnapshotVec<D> {
     type Target = [D::Value];
-    fn deref(&self) -> &[D::Value] { &*self.values }
+    fn deref(&self) -> &[D::Value] {
+        &*self.values
+    }
 }
 
 impl<D: SnapshotVecDelegate> ops::DerefMut for SnapshotVec<D> {
-    fn deref_mut(&mut self) -> &mut [D::Value] { &mut *self.values }
+    fn deref_mut(&mut self) -> &mut [D::Value] {
+        &mut *self.values
+    }
 }
 
 impl<D: SnapshotVecDelegate> ops::Index<usize> for SnapshotVec<D> {
     type Output = D::Value;
-    fn index(&self, index: usize) -> &D::Value { self.get(index) }
+    fn index(&self, index: usize) -> &D::Value {
+        self.get(index)
+    }
 }
 
 impl<D: SnapshotVecDelegate> ops::IndexMut<usize> for SnapshotVec<D> {
-    fn index_mut(&mut self, index: usize) -> &mut D::Value { self.get_mut(index) }
+    fn index_mut(&mut self, index: usize) -> &mut D::Value {
+        self.get_mut(index)
+    }
 }

src/librustc_data_structures/transitive_relation.rs

@@ -33,7 +33,7 @@ pub struct TransitiveRelation<T:Debug+PartialEq> {
     // are added with new elements. Perhaps better would be to ask the
     // user for a batch of edges to minimize this effect, but I
     // already wrote the code this way. :P -nmatsakis
-    closure: RefCell<Option<BitMatrix>>
+    closure: RefCell<Option<BitMatrix>>,
 }
 
 #[derive(Clone, PartialEq, PartialOrd)]
@@ -47,9 +47,11 @@ struct Edge {
 
 impl<T: Debug + PartialEq> TransitiveRelation<T> {
     pub fn new() -> TransitiveRelation<T> {
-        TransitiveRelation { elements: vec![],
+        TransitiveRelation {
+            elements: vec![],
             edges: vec![],
-                             closure: RefCell::new(None) }
+            closure: RefCell::new(None),
+        }
     }
 
     fn index(&self, a: &T) -> Option<Index> {
@@ -74,7 +76,10 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
     pub fn add(&mut self, a: T, b: T) {
         let a = self.add_index(a);
         let b = self.add_index(b);
-        let edge = Edge { source: a, target: b };
+        let edge = Edge {
+            source: a,
+            target: b,
+        };
         if !self.edges.contains(&edge) {
             self.edges.push(edge);
 
@@ -86,10 +91,8 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
     /// Check whether `a < target` (transitively)
     pub fn contains(&self, a: &T, b: &T) -> bool {
         match (self.index(a), self.index(b)) {
-            (Some(a), Some(b)) =>
+            (Some(a), Some(b)) => self.with_closure(|closure| closure.contains(a.0, b.0)),
-                self.with_closure(|closure| closure.contains(a.0, b.0)),
+            (None, _) | (_, None) => false,
-            (None, _) | (_, None) =>
-                false,
         }
     }
 
@@ -156,7 +159,9 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
     pub fn minimal_upper_bounds(&self, a: &T, b: &T) -> Vec<&T> {
         let (mut a, mut b) = match (self.index(a), self.index(b)) {
             (Some(a), Some(b)) => (a, b),
-            (None, _) | (_, None) => { return vec![]; }
+            (None, _) | (_, None) => {
+                return vec![];
+            }
         };
 
         // in some cases, there are some arbitrary choices to be made;
@@ -438,7 +443,8 @@ fn pdub_crisscross() {
     relation.add("a1", "x");
     relation.add("b1", "x");
 
-    assert_eq!(relation.minimal_upper_bounds(&"a", &"b"), vec![&"a1", &"b1"]);
+    assert_eq!(relation.minimal_upper_bounds(&"a", &"b"),
+               vec![&"a1", &"b1"]);
     assert_eq!(relation.postdom_upper_bound(&"a", &"b"), Some(&"x"));
 }
 
@@ -466,8 +472,10 @@ fn pdub_crisscross_more() {
     relation.add("a3", "x");
     relation.add("b2", "x");
 
-    assert_eq!(relation.minimal_upper_bounds(&"a", &"b"), vec![&"a1", &"b1"]);
+    assert_eq!(relation.minimal_upper_bounds(&"a", &"b"),
-    assert_eq!(relation.minimal_upper_bounds(&"a1", &"b1"), vec![&"a2", &"b2"]);
+               vec![&"a1", &"b1"]);
+    assert_eq!(relation.minimal_upper_bounds(&"a1", &"b1"),
+               vec![&"a2", &"b2"]);
     assert_eq!(relation.postdom_upper_bound(&"a", &"b"), Some(&"x"));
 }
 

src/librustc_data_structures/unify/mod.rs

@@ -85,9 +85,11 @@ impl<K:UnifyKey> VarValue<K> {
     }
 
     fn new(parent: K, value: K::Value, rank: u32) -> VarValue<K> {
-        VarValue { parent: parent, // this is a root
+        VarValue {
+            parent: parent, // this is a root
             value: value,
-                   rank: rank }
+            rank: rank,
+        }
     }
 
     fn redirect(self, to: K) -> VarValue<K> {
@@ -95,7 +97,11 @@ impl<K:UnifyKey> VarValue<K> {
     }
 
     fn root(self, rank: u32, value: K::Value) -> VarValue<K> {
-        VarValue { rank: rank, value: value, ..self }
+        VarValue {
+            rank: rank,
+            value: value,
+            ..self
+        }
     }
 
     /// Returns the key of this node. Only valid if this is a root
@@ -124,16 +130,16 @@ impl<K:UnifyKey> VarValue<K> {
 
 impl<K: UnifyKey> UnificationTable<K> {
     pub fn new() -> UnificationTable<K> {
-        UnificationTable {
+        UnificationTable { values: sv::SnapshotVec::new() }
-            values: sv::SnapshotVec::new()
-        }
     }
 
     /// Starts a new snapshot. Each snapshot must be either
     /// rolled back or committed in a "LIFO" (stack) order.
     pub fn snapshot(&mut self) -> Snapshot<K> {
-        Snapshot { marker: marker::PhantomData::<K>,
+        Snapshot {
-                   snapshot: self.values.start_snapshot() }
+            marker: marker::PhantomData::<K>,
+            snapshot: self.values.start_snapshot(),
+        }
     }
 
     /// Reverses all changes since the last snapshot. Also
@@ -154,9 +160,7 @@ impl<K:UnifyKey> UnificationTable<K> {
         let len = self.values.len();
         let key: K = UnifyKey::from_index(len as u32);
         self.values.push(VarValue::new_var(key, value));
-        debug!("{}: created new key: {:?}",
+        debug!("{}: created new key: {:?}", UnifyKey::tag(None::<K>), key);
-               UnifyKey::tag(None::<K>),
-               key);
         key
     }
 
@@ -179,9 +183,7 @@ impl<K:UnifyKey> UnificationTable<K> {
                 }
                 root
             }
-            None => {
+            None => value,
-                value
-            }
         }
     }
 
@@ -195,8 +197,7 @@ impl<K:UnifyKey> UnificationTable<K> {
     fn set(&mut self, key: K, new_value: VarValue<K>) {
         assert!(self.is_root(key));
 
-        debug!("Updating variable {:?} to {:?}",
+        debug!("Updating variable {:?} to {:?}", key, new_value);
-               key, new_value);
 
         let index = key.index() as usize;
         self.values.set(index, new_value);
@@ -287,28 +288,22 @@ impl<'tcx,K:UnifyKey> UnificationTable<K>
 
 impl<'tcx, K, V> UnificationTable<K>
     where K: UnifyKey<Value = Option<V>>,
-          V: Clone+PartialEq+Debug,
+          V: Clone + PartialEq + Debug
-{
-    pub fn unify_var_var(&mut self,
-                         a_id: K,
-                         b_id: K)
-                         -> Result<(),(V,V)>
 {
+    pub fn unify_var_var(&mut self, a_id: K, b_id: K) -> Result<(), (V, V)> {
         let node_a = self.get(a_id);
         let node_b = self.get(b_id);
         let a_id = node_a.key();
         let b_id = node_b.key();
 
-        if a_id == b_id { return Ok(()); }
+        if a_id == b_id {
+            return Ok(());
+        }
 
         let combined = {
             match (&node_a.value, &node_b.value) {
-                (&None, &None) => {
+                (&None, &None) => None,
-                    None
+                (&Some(ref v), &None) | (&None, &Some(ref v)) => Some(v.clone()),
-                }
-                (&Some(ref v), &None) | (&None, &Some(ref v)) => {
-                    Some(v.clone())
-                }
                 (&Some(ref v1), &Some(ref v2)) => {
                     if *v1 != *v2 {
                         return Err((v1.clone(), v2.clone()));
@@ -323,11 +318,7 @@ impl<'tcx,K,V> UnificationTable<K>
 
     /// Sets the value of the key `a_id` to `b`. Because simple keys do not have any subtyping
     /// relationships, if `a_id` already has a value, it must be the same as `b`.
-    pub fn unify_var_value(&mut self,
+    pub fn unify_var_value(&mut self, a_id: K, b: V) -> Result<(), (V, V)> {
-                           a_id: K,
-                           b: V)
-                           -> Result<(),(V,V)>
-    {
         let mut node_a = self.get(a_id);
 
         match node_a.value {
@@ -358,7 +349,13 @@ impl<'tcx,K,V> UnificationTable<K>
     pub fn unsolved_variables(&mut self) -> Vec<K> {
         self.values
             .iter()
-            .filter_map(|vv| if vv.value.is_some() { None } else { Some(vv.key()) })
+            .filter_map(|vv| {
+                if vv.value.is_some() {
+                    None
+                } else {
+                    Some(vv.key())
+                }
+            })
             .collect()
     }
 }

src/librustc_data_structures/unify/tests.rs

@@ -19,9 +19,15 @@ struct UnitKey(u32);
 
 impl UnifyKey for UnitKey {
     type Value = ();
-    fn index(&self) -> u32 { self.0 }
+    fn index(&self) -> u32 {
-    fn from_index(u: u32) -> UnitKey { UnitKey(u) }
+        self.0
-    fn tag(_: Option<UnitKey>) -> &'static str { "UnitKey" }
+    }
+    fn from_index(u: u32) -> UnitKey {
+        UnitKey(u)
+    }
+    fn tag(_: Option<UnitKey>) -> &'static str {
+        "UnitKey"
+    }
 }
 
 #[test]
@@ -108,9 +114,15 @@ struct IntKey(u32);
 
 impl UnifyKey for IntKey {
     type Value = Option<i32>;
-    fn index(&self) -> u32 { self.0 }
+    fn index(&self) -> u32 {
-    fn from_index(u: u32) -> IntKey { IntKey(u) }
+        self.0
-    fn tag(_: Option<IntKey>) -> &'static str { "IntKey" }
+    }
+    fn from_index(u: u32) -> IntKey {
+        IntKey(u)
+    }
+    fn tag(_: Option<IntKey>) -> &'static str {
+        "IntKey"
+    }
 }
 
 /// Test unifying a key whose value is `Some(_)`  with a key whose value is `None`.
@@ -191,4 +203,3 @@ fn unify_key_Some_x_val_x() {
     assert!(ut.unify_var_value(k1, 22).is_ok());
     assert_eq!(ut.probe(k1), Some(22));
 }
-

src/librustc_data_structures/veccell/mod.rs

@@ -12,7 +12,7 @@ use std::cell::UnsafeCell;
 use std::mem;
 
 pub struct VecCell<T> {
-    data: UnsafeCell<Vec<T>>
+    data: UnsafeCell<Vec<T>>,
 }
 
 impl<T> VecCell<T> {