---

yaml
---
r: 233590
b: refs/heads/beta
c: a54b91f
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: b247402666d1c149005de1d341f3fa49fb2943a4
+refs/heads/beta: a54b91ff5bb1672ba0dc83a5ead0e599723714f6
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/librustc_data_structures/transitive_relation.rs

@@ -267,8 +267,7 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
 /// there exists an earlier element i<j such that i -> j. That is,
 /// after you run `pare_down`, you know that for all elements that
 /// remain in candidates, they cannot reach any of the elements that
-/// come after them. (Note that it may permute the ordering in some
-/// cases.)
+/// come after them.
 ///
 /// Examples follow. Assume that a -> b -> c and x -> y -> z.
 ///
@@ -278,24 +277,24 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
 fn pare_down(candidates: &mut Vec<usize>, closure: &BitMatrix) {
     let mut i = 0;
     while i < candidates.len() {
-        let candidate = candidates[i];
+        let candidate_i = candidates[i];
         i += 1;
 
         let mut j = i;
+        let mut dead = 0;
         while j < candidates.len() {
-            if closure.contains(candidate, candidates[j]) {
-                // If `i` can reach `j`, then we can remove `j`. Given
-                // how careful this algorithm is about ordering, it
-                // may seem odd to use swap-remove. The reason it is
-                // ok is that we are swapping two elements (`j` and
-                // `max`) that are both to the right of our cursor
-                // `i`, and the invariant that we are establishing
-                // continues to hold for everything left of `i`.
-                candidates.swap_remove(j);
+            let candidate_j = candidates[j];
+            if closure.contains(candidate_i, candidate_j) {
+                // If `i` can reach `j`, then we can remove `j`. So just
+                // mark it as dead and move on; subsequent indices will be
+                // shifted into its place.
+                dead += 1;
             } else {
-                j += 1;
+                candidates[j - dead] = candidate_j;
             }
+            j += 1;
         }
+        candidates.truncate(j - dead);
     }
 }