---

yaml
---
r: 38070
b: refs/heads/try
c: 1fdfd3b
h: refs/heads/master
v: v3

Author: Jakub Wieczorek

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: 856dbac56726e34a010d2a74d5e19ef5c3e2ede3
+refs/heads/try: 1fdfd3b1d60b49a9f3c248781c7a82c617c55769
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/librustc/middle/check_alt.rs

@@ -392,49 +392,49 @@ fn missing_ctor(cx: @AltCheckCtxt,
         else { Some(val(const_bool(true))) }
       }
       ty::ty_unboxed_vec(*) | ty::ty_evec(*) => {
-        let max_len = do m.foldr(0) |r, max_len| {
-          match r[0].node {
-            pat_vec(elems, _) => uint::max(elems.len(), max_len),
-            _ => max_len
-          }
-        };
-        let min_len_with_tail = do m.foldr(max_len + 1) |r, min_len| {
-          match r[0].node {
-            pat_vec(elems, tail) => {
-              if tail.is_some() && elems.len() < min_len {
-                elems.len()
-              } else {
-                min_len
-              }
-            }
-            _ => min_len
-          }
-        };
-        let vec_lens = do m.filter_map |r| {
-          match r[0].node {
-            pat_vec(elems, tail) => {
-              match tail {
-                None if elems.len() < min_len_with_tail => Some(elems.len()),
+
+        // Find the lengths and tails of all vector patterns.
+        let vec_pat_lens = do m.filter_map |r| {
+            match r[0].node {
+                pat_vec(elems, tail) => {
+                    Some((elems.len(), tail.is_some()))
+                }
                 _ => None
-              }
             }
-            _ => None
-          }
-        };
-        let mut sorted_vec_lens = do sort::merge_sort(vec_lens) |a, b| {
-          a < b
         };
+
+        // Sort them by length such that for patterns of the same length,
+        // those with a destructured tail come first.
+        let mut sorted_vec_lens = sort::merge_sort(vec_pat_lens,
+            |&(len1, tail1), &(len2, tail2)| {
+                if len1 == len2 {
+                    tail1 > tail2
+                } else {
+                    len1 <= len2
+                }
+            }
+        );
         vec::dedup(&mut sorted_vec_lens);
 
+        let mut found_tail = false;
+        let mut next = 0;
         let mut missing = None;
-        for uint::range(0, min_len_with_tail) |i| {
-          if i >= sorted_vec_lens.len() || i != sorted_vec_lens[i] {
-            missing = Some(i);
-            break;
-          }
-        };
-        if missing.is_none() && min_len_with_tail > max_len {
-          missing = Some(min_len_with_tail);
+        for sorted_vec_lens.each |&(length, tail)| {
+            if length != next {
+                missing = Some(next);
+                break;
+            }
+            if tail {
+                found_tail = true;
+                break;
+            }
+            next += 1;
+        }
+
+        // We found patterns of all lengths within <0, next), yet there was no
+        // pattern with a tail - therefore, we report vec(next) as missing.
+        if !found_tail {
+            missing = Some(next);
         }
         match missing {
           Some(k) => Some(vec(k)),