---

yaml
---
r: 63084
b: refs/heads/snap-stage3
c: bc81d27
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f661a15b2bd5c2a9ea984c72c28caf970317d8a3
+refs/heads/snap-stage3: bc81d279fa04de7c956871ff6668d2a3d5e6d78c
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/const_eval.rs

@@ -242,7 +242,7 @@ pub enum const_val {
 pub fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
     match eval_const_expr_partial(tcx, e) {
         Ok(ref r) => (/*bad*/copy *r),
-        Err(ref s) => fail!(/*bad*/copy *s)
+        Err(ref s) => tcx.sess.span_fatal(e.span, *s)
     }
 }
 

branches/snap-stage3/src/librustc/middle/kind.rs

@@ -17,7 +17,6 @@ use middle::typeck;
 use util::ppaux::{Repr, ty_to_str};
 use util::ppaux::UserString;
 
-use core::iterator::IteratorUtil;
 use core::vec;
 use syntax::ast::*;
 use syntax::attr::attrs_contains_name;
@@ -269,7 +268,7 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
                   ts.repr(cx.tcx),
                   type_param_defs.repr(cx.tcx));
         }
-        for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
+        for vec::each2(**ts, *type_param_defs) |&ty, type_param_def| {
             check_bounds(cx, type_parameter_id, e.span, ty, type_param_def)
         }
     }
@@ -310,7 +309,7 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt<Context>) {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&id));
             let type_param_defs =
                 ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
-            for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
+            for vec::each2(**ts, *type_param_defs) |&ty, type_param_def| {
                 check_bounds(cx, aty.id, aty.span, ty, type_param_def)
             }
         }

branches/snap-stage3/src/librustc/middle/trans/inline.rs

@@ -19,7 +19,6 @@ use middle::trans::common::*;
 use middle::ty;
 use util::ppaux::ty_to_str;
 
-use core::iterator::IteratorUtil;
 use core::vec;
 use syntax::ast;
 use syntax::ast_map::path_name;
@@ -76,7 +75,7 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::def_id,
             ast::item_enum(_, _) => {
               let vs_here = ty::enum_variants(ccx.tcx, local_def(item.id));
               let vs_there = ty::enum_variants(ccx.tcx, parent_id);
-              for vs_here.iter().zip(vs_there.iter()).advance |(here, there)| {
+              for vec::each2(*vs_here, *vs_there) |here, there| {
                   if there.id == fn_id { my_id = here.id.node; }
                   ccx.external.insert(there.id, Some(here.id.node));
               }

branches/snap-stage3/src/librustc/middle/trans/type_use.rs

@@ -33,7 +33,6 @@ use middle::trans::inline;
 use middle::ty;
 use middle::typeck;
 
-use core::iterator::IteratorUtil;
 use core::option::{Some, None};
 use core::uint;
 use core::vec;
@@ -265,7 +264,7 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
     for opt_static_did.each |&did| {
         for cx.ccx.tcx.node_type_substs.find_copy(&callee_id).each |ts| {
             let type_uses = type_uses_for(cx.ccx, did, ts.len());
-            for type_uses.iter().zip(ts.iter()).advance |(uses, subst)| {
+            for vec::each2(*type_uses, *ts) |uses, subst| {
                 type_needs(cx, *uses, *subst)
             }
         }
@@ -303,7 +302,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
         for opt_ts.each |ts| {
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get_copy(&e.id));
             let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
-            for uses_for_ts.iter().zip(ts.iter()).advance |(uses, subst)| {
+            for vec::each2(*uses_for_ts, *ts) |uses, subst| {
                 type_needs(cx, *uses, *subst)
             }
         }

branches/snap-stage3/src/librustc/middle/typeck/check/_match.rs

@@ -18,8 +18,8 @@ use middle::typeck::check::{instantiate_path, lookup_def};
 use middle::typeck::check::{structure_of, valid_range_bounds};
 use middle::typeck::require_same_types;
 
-use core::iterator::IteratorUtil;
 use core::hashmap::{HashMap, HashSet};
+use core::vec;
 use syntax::ast;
 use syntax::ast_util;
 use syntax::codemap::span;
@@ -232,7 +232,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
 
         if !error_happened {
             for subpats.each |pats| {
-                for pats.iter().zip(arg_types.iter()).advance |(subpat, arg_ty)| {
+                for vec::each2(*pats, arg_types) |subpat, arg_ty| {
                     check_pat(pcx, *subpat, *arg_ty);
                 }
             }

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -110,8 +110,6 @@ use util::common::{block_query, indenter, loop_query};
 use util::ppaux::{bound_region_to_str};
 use util::ppaux;
 
-
-use core::iterator::IteratorUtil;
 use core::cast::transmute;
 use core::hashmap::HashMap;
 use core::result;
@@ -414,7 +412,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
     for opt_self_info.each |self_info| {
         fcx.write_ty(self_info.self_id, self_info.self_ty);
     }
-    for decl.inputs.iter().zip(arg_tys.iter()).advance |(input, arg)| {
+    for vec::each2(decl.inputs, arg_tys) |input, arg| {
         fcx.write_ty(input.id, *arg);
     }
 
@@ -451,7 +449,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
         }
 
         // Add formal parameters.
-        for arg_tys.iter().zip(decl.inputs.iter()).advance |(arg_ty, input)| {
+        for vec::each2(arg_tys, decl.inputs) |arg_ty, input| {
             // Create type variables for each argument.
             do pat_util::pat_bindings(tcx.def_map, input.pat)
                     |_bm, pat_id, _sp, _path| {

branches/snap-stage3/src/librustc/middle/typeck/coherence.rs

@@ -54,7 +54,6 @@ use syntax::visit::{Visitor, SimpleVisitor};
 use syntax::visit::{visit_mod};
 use util::ppaux::ty_to_str;
 
-use core::iterator::IteratorUtil;
 use core::hashmap::{HashMap, HashSet};
 use core::old_iter;
 use core::result::Ok;
@@ -618,9 +617,9 @@ impl CoherenceChecker {
                 // Check to ensure that each parameter binding respected its
                 // kind bounds.
                 for [ a, b ].each |result| {
-                    for result.type_variables.iter()
-                        .zip(result.type_param_defs.iter())
-                        .advance |(ty_var, type_param_def)|
+                    for vec::each2(result.type_variables,
+                                   *result.type_param_defs)
+                        |ty_var, type_param_def|
                     {
                         if type_param_def.bounds.builtin_bounds.contains_elem(
                             ty::BoundCopy)

branches/snap-stage3/src/libstd/iterator.rs

@@ -55,7 +55,7 @@ pub trait IteratorUtil<A> {
     /// assert_eq!(it.next().get(), &1);
     /// assert!(it.next().is_none());
     /// ~~~
-    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<A, Self, U>;
+    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<Self, U>;
 
     /// Creates an iterator which iterates over both this and the specified
     /// iterators simultaneously, yielding the two elements as pairs. When
@@ -73,7 +73,7 @@ pub trait IteratorUtil<A> {
     /// assert_eq!(it.next().get(), (&0, &1));
     /// assert!(it.next().is_none());
     /// ~~~
-    fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<A, Self, B, U>;
+    fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<Self, U>;
 
     // FIXME: #5898: should be called map
     /// Creates a new iterator which will apply the specified function to each
@@ -139,7 +139,7 @@ pub trait IteratorUtil<A> {
     /// assert_eq!(it.next().get(), (1, &200));
     /// assert!(it.next().is_none());
     /// ~~~
-    fn enumerate(self) -> EnumerateIterator<A, Self>;
+    fn enumerate(self) -> EnumerateIterator<Self>;
 
     /// Creates an iterator which invokes the predicate on elements until it
     /// returns true. Once the predicate returns true, all further elements are
@@ -349,12 +349,12 @@ pub trait IteratorUtil<A> {
 /// In the future these will be default methods instead of a utility trait.
 impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     #[inline(always)]
-    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<A, T, U> {
+    fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<T, U> {
         ChainIterator{a: self, b: other, flag: false}
     }
 
     #[inline(always)]
-    fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<A, T, B, U> {
+    fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<T, U> {
         ZipIterator{a: self, b: other}
     }
 
@@ -375,7 +375,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     }
 
     #[inline(always)]
-    fn enumerate(self) -> EnumerateIterator<A, T> {
+    fn enumerate(self) -> EnumerateIterator<T> {
         EnumerateIterator{iter: self, count: 0}
     }
 
@@ -570,14 +570,13 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
 }
 
 /// An iterator which strings two iterators together
-// FIXME #6967: Dummy A parameter to get around type inference bug
-pub struct ChainIterator<A, T, U> {
+pub struct ChainIterator<T, U> {
     priv a: T,
     priv b: U,
     priv flag: bool
 }
 
-impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<A, T, U> {
+impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<T, U> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.flag {
@@ -594,13 +593,12 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<A, T, U> {
 }
 
 /// An iterator which iterates two other iterators simultaneously
-// FIXME #6967: Dummy A & B parameters to get around type inference bug
-pub struct ZipIterator<A, T, B, U> {
+pub struct ZipIterator<T, U> {
     priv a: T,
     priv b: U
 }
 
-impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for ZipIterator<A, T, B, U> {
+impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for ZipIterator<T, U> {
     #[inline]
     fn next(&mut self) -> Option<(A, B)> {
         match (self.a.next(), self.b.next()) {
@@ -666,13 +664,12 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMapIterator<'self, A, B,
 }
 
 /// An iterator which yields the current count and the element during iteration
-// FIXME #6967: Dummy A parameter to get around type inference bug
-pub struct EnumerateIterator<A, T> {
+pub struct EnumerateIterator<T> {
     priv iter: T,
     priv count: uint
 }
 
-impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<A, T> {
+impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<T> {
     #[inline]
     fn next(&mut self) -> Option<(uint, A)> {
         match self.iter.next() {
@@ -890,7 +887,7 @@ mod tests {
         let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
         let mut it = xs.iter().chain(ys.iter());
         let mut i = 0;
-        for it.advance |&x| {
+        for it.advance |&x: &uint| {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -899,7 +896,7 @@ mod tests {
         let ys = Counter::new(30u, 10).take(4);
         let mut it = xs.iter().transform(|&x| x).chain(ys);
         let mut i = 0;
-        for it.advance |x| {
+        for it.advance |x: uint| {
             assert_eq!(x, expected[i]);
             i += 1;
         }
@@ -909,15 +906,15 @@ mod tests {
     #[test]
     fn test_filter_map() {
         let mut it = Counter::new(0u, 1u).take(10)
-            .filter_map(|x| if x.is_even() { Some(x*x) } else { None });
+            .filter_map(|x: uint| if x.is_even() { Some(x*x) } else { None });
         assert_eq!(it.collect::<~[uint]>(), ~[0*0, 2*2, 4*4, 6*6, 8*8]);
     }
 
     #[test]
     fn test_iterator_enumerate() {
         let xs = [0u, 1, 2, 3, 4, 5];
         let mut it = xs.iter().enumerate();
-        for it.advance |(i, &x)| {
+        for it.advance |(i, &x): (uint, &uint)| {
             assert_eq!(i, x);
         }
     }
@@ -928,7 +925,7 @@ mod tests {
         let ys = [0u, 1, 2, 3, 5, 13];
         let mut it = xs.iter().take_while(|&x| *x < 15u);
         let mut i = 0;
-        for it.advance |&x| {
+        for it.advance |&x: &uint| {
             assert_eq!(x, ys[i]);
             i += 1;
         }
@@ -941,7 +938,7 @@ mod tests {
         let ys = [15, 16, 17, 19];
         let mut it = xs.iter().skip_while(|&x| *x < 15u);
         let mut i = 0;
-        for it.advance |&x| {
+        for it.advance |&x: &uint| {
             assert_eq!(x, ys[i]);
             i += 1;
         }

branches/snap-stage3/src/libstd/vec.rs

@@ -1666,6 +1666,44 @@ pub fn eachi_reverse<'r,T>(v: &'r [T],
     return true;
 }
 
+/**
+ * Iterates over two vectors simultaneously
+ *
+ * # Failure
+ *
+ * Both vectors must have the same length
+ */
+#[inline]
+pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool {
+    assert_eq!(v1.len(), v2.len());
+    for uint::range(0u, v1.len()) |i| {
+        if !f(&v1[i], &v2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ *
+ * Iterates over two vector with mutable.
+ *
+ * # Failure
+ *
+ * Both vectors must have the same length
+ */
+#[inline]
+pub fn each2_mut<U, T>(v1: &mut [U], v2: &mut [T],
+                       f: &fn(u: &mut U, t: &mut T) -> bool) -> bool {
+    assert_eq!(v1.len(), v2.len());
+    for uint::range(0u, v1.len()) |i| {
+        if !f(&mut v1[i], &mut v2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 /**
  * Iterate over all permutations of vector `v`.
  *

branches/snap-stage3/src/libsyntax/ext/deriving/generic.rs

@@ -174,7 +174,6 @@ use opt_vec;
 
 use core::uint;
 use core::vec;
-use core::iterator::IteratorUtil;
 
 pub use self::ty::*;
 mod ty;
@@ -617,7 +616,7 @@ impl<'self> MethodDef<'self> {
         // make a series of nested matches, to destructure the
         // structs. This is actually right-to-left, but it shoudn't
         // matter.
-        for self_args.iter().zip(patterns.iter()).advance |(&arg_expr, &pat)| {
+        for vec::each2(self_args, patterns) |&arg_expr, &pat| {
             body = cx.expr_match(span, arg_expr,
                                  ~[ cx.arm(span, ~[pat], body) ])
         }
@@ -952,7 +951,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
     // must be nonempty to reach here
     let pattern = if struct_type == Record {
         let field_pats = do vec::build |push| {
-            for subpats.iter().zip(ident_expr.iter()).advance |(&pat, &(id, _))| {
+            for vec::each2(subpats, ident_expr) |&pat, &(id, _)| {
                 // id is guaranteed to be Some
                 push(ast::field_pat { ident: id.get(), pat: pat })
             }

branches/snap-stage3/src/test/bench/shootout-fannkuch-redux.rs

@@ -1,4 +1,3 @@
-use std::iterator::*;
 use std::from_str::FromStr;
 use std::i32::range;
 use std::os;
@@ -30,8 +29,9 @@ fn fannkuch_redux(n: i32) -> i32 {
                 r -= 1;
             }
 
-            for perm.mut_iter().zip(perm1.iter()).advance |(perm_i, perm1_i)| {
-                *perm_i = *perm1_i;
+            // XXX: Need each2_mut.
+            for vec::eachi_mut(perm) |i, perm_i| {
+                *perm_i = perm1.unsafe_get(i);
             }
 
             let mut flips_count: i32 = 0;