Continue fixing comparisons

Author: pierwill

compiler/rustc_data_structures/src/graph/dominators/mod.rs

@@ -21,7 +21,7 @@ pub fn dominators<G: ControlFlowGraph>(graph: G) -> Dominators<G::Node> {
 
 fn dominators_given_rpo<G: ControlFlowGraph>(graph: G, rpo: &[G::Node]) -> Dominators<G::Node> {
     let start_node = graph.start_node();
-    assert_eq!(rpo[0], start_node);
+    assert_eq!(rpo[0].index(), start_node.index());
 
     // compute the post order index (rank) for each node
     let mut post_order_rank = IndexVec::from_elem_n(0, graph.num_nodes());
@@ -49,7 +49,9 @@ fn dominators_given_rpo<G: ControlFlowGraph>(graph: G, rpo: &[G::Node]) -> Domin
                 }
             }
 
-            if new_idom != immediate_dominators[node] {
+            if new_idom.clone().unwrap().index()
+                != immediate_dominators[node].clone().unwrap().index()
+            {
                 immediate_dominators[node] = new_idom;
                 changed = true;
             }
@@ -65,7 +67,7 @@ fn intersect<Node: Idx>(
     mut node1: Node,
     mut node2: Node,
 ) -> Node {
-    while node1 != node2 {
+    while node1.index() != node2.index() {
         while post_order_rank[node1] < post_order_rank[node2] {
             node1 = immediate_dominators[node1].unwrap();
         }
@@ -105,7 +107,7 @@ impl<Node: Idx> Dominators<Node> {
 
     pub fn is_dominated_by(&self, node: Node, dom: Node) -> bool {
         // FIXME -- could be optimized by using post-order-rank
-        self.dominators(node).any(|n| n == dom)
+        self.dominators(node).any(|n| n.index() == dom.index())
     }
 
     /// Provide deterministic ordering of nodes such that, if any two nodes have a dominator
@@ -128,7 +130,7 @@ impl<'dom, Node: Idx> Iterator for Iter<'dom, Node> {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(node) = self.node {
             let dom = self.dominators.immediate_dominator(node);
-            if dom == node {
+            if dom.index() == node.index() {
                 self.node = None; // reached the root
             } else {
                 self.node = Some(dom);

compiler/rustc_data_structures/src/graph/scc/mod.rs

@@ -311,7 +311,7 @@ where
                     // We test this, to be extremely sure that we never
                     // ever break our termination condition for the
                     // reverse iteration loop.
-                    assert!(node != parent, "Node can not be in cycle with itself");
+                    assert!(node.index() != parent.index(), "Node can not be in cycle with itself");
                     // Store the previous node as an inverted list link
                     self.node_states[node] = NodeState::InCycleWith { parent: previous_node };
                     // Update to parent node.
@@ -359,7 +359,7 @@ where
         // will know when we hit the state where previous_node == node.
         loop {
             // Back at the beginning, we can return.
-            if previous_node == node {
+            if previous_node.index() == node.index() {
                 return node_state;
             }
             // Update to previous node in the link.

compiler/rustc_data_structures/src/graph/vec_graph/mod.rs

@@ -20,7 +20,7 @@ pub struct VecGraph<N: Idx> {
 impl<N: Idx> VecGraph<N> {
     pub fn new(num_nodes: usize, mut edge_pairs: Vec<(N, N)>) -> Self {
         // Sort the edges by the source -- this is important.
-        edge_pairs.sort();
+        edge_pairs.sort_by_cached_key(|&edge_pairs| (edge_pairs.0.index(), edge_pairs.1.index()));
 
         let num_edges = edge_pairs.len();
 

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -19,7 +19,7 @@ pub type SimplifiedType = SimplifiedTypeGen<DefId>;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, TyEncodable, TyDecodable)]
 pub enum SimplifiedTypeGen<D>
 where
-    D: Copy + Debug + Ord + Eq,
+    D: Copy + Debug + Eq,
 {
     BoolSimplifiedType,
     CharSimplifiedType,