---

yaml
---
r: 64819
b: refs/heads/snap-stage3
c: 4b45f47
h: refs/heads/master
i:
  64817: 8bed96d
  64815: 28f2c59
v: v3

Author: blake2-ppc

[refs]

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

branches/snap-stage3/src/libextra/dlist.rs

@@ -25,7 +25,7 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iterator::{FromIterator, InvertIterator};
+use std::iterator::{FromIterator, Invert};
 
 use container::Deque;
 
@@ -356,7 +356,7 @@ impl<T> DList<T> {
 
     /// Provide a reverse iterator
     #[inline]
-    pub fn rev_iter<'a>(&'a self) -> InvertIterator<DListIterator<'a, T>> {
+    pub fn rev_iter<'a>(&'a self) -> Invert<DListIterator<'a, T>> {
         self.iter().invert()
     }
 
@@ -376,7 +376,7 @@ impl<T> DList<T> {
     }
     /// Provide a reverse iterator with mutable references
     #[inline]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator<MutDListIterator<'a, T>> {
+    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<MutDListIterator<'a, T>> {
         self.mut_iter().invert()
     }
 
@@ -389,7 +389,7 @@ impl<T> DList<T> {
 
     /// Consume the list into an iterator yielding elements by value, in reverse
     #[inline]
-    pub fn consume_rev_iter(self) -> InvertIterator<ConsumeIterator<T>> {
+    pub fn consume_rev_iter(self) -> Invert<ConsumeIterator<T>> {
         self.consume_iter().invert()
     }
 }

branches/snap-stage3/src/libextra/ringbuf.rs

@@ -16,7 +16,7 @@
 use std::num;
 use std::uint;
 use std::vec;
-use std::iterator::{FromIterator, InvertIterator};
+use std::iterator::{FromIterator, Invert};
 
 use container::Deque;
 
@@ -181,7 +181,7 @@ impl<T> RingBuf<T> {
     }
 
     /// Back-to-front iterator.
-    pub fn rev_iter<'a>(&'a self) -> InvertIterator<RingBufIterator<'a, T>> {
+    pub fn rev_iter<'a>(&'a self) -> Invert<RingBufIterator<'a, T>> {
         self.iter().invert()
     }
 
@@ -192,7 +192,7 @@ impl<T> RingBuf<T> {
     }
 
     /// Back-to-front iterator which returns mutable values.
-    pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator<RingBufMutIterator<'a, T>> {
+    pub fn mut_rev_iter<'a>(&'a mut self) -> Invert<RingBufMutIterator<'a, T>> {
         self.mut_iter().invert()
     }
 }

branches/snap-stage3/src/libextra/smallintmap.rs

@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use std::iterator::{Iterator, IteratorUtil, EnumerateIterator, FilterMapIterator, InvertIterator};
+use std::iterator::{Iterator, IteratorUtil, Enumerate, FilterMap, Invert};
 use std::uint;
 use std::util::replace;
 use std::vec::{VecIterator, VecMutIterator};
@@ -204,8 +204,8 @@ impl<V> SmallIntMap<V> {
 
     /// Empties the hash map, moving all values into the specified closure
     pub fn consume(&mut self)
-        -> FilterMapIterator<(uint, Option<V>), (uint, V),
-                EnumerateIterator<vec::ConsumeIterator<Option<V>>>>
+        -> FilterMap<(uint, Option<V>), (uint, V),
+                Enumerate<vec::ConsumeIterator<Option<V>>>>
     {
         let values = replace(&mut self.v, ~[]);
         values.consume_iter().enumerate().filter_map(|(i, v)| {
@@ -291,7 +291,7 @@ pub struct SmallIntMapIterator<'self, T> {
 
 iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref)
 double_ended_iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref)
-pub type SmallIntMapRevIterator<'self, T> = InvertIterator<SmallIntMapIterator<'self, T>>;
+pub type SmallIntMapRevIterator<'self, T> = Invert<SmallIntMapIterator<'self, T>>;
 
 pub struct SmallIntMapMutIterator<'self, T> {
     priv front: uint,
@@ -301,7 +301,7 @@ pub struct SmallIntMapMutIterator<'self, T> {
 
 iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref)
 double_ended_iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref)
-pub type SmallIntMapMutRevIterator<'self, T> = InvertIterator<SmallIntMapMutIterator<'self, T>>;
+pub type SmallIntMapMutRevIterator<'self, T> = Invert<SmallIntMapMutIterator<'self, T>>;
 
 #[cfg(test)]
 mod test_map {

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

@@ -160,7 +160,7 @@ pub fn check_expr(sess: Session,
           expr_field(*) |
           expr_index(*) |
           expr_tup(*) |
-          expr_struct(*) => { }
+          expr_struct(_, _, None) => { }
           expr_addr_of(*) => {
                 sess.span_err(
                     e.span,

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

@@ -485,30 +485,20 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::expr) -> ValueRef {
               let vals = es.map(|&e| const_expr(cx, e));
               adt::trans_const(cx, repr, 0, vals)
           }
-          ast::expr_struct(_, ref fs, ref base_opt) => {
+          ast::expr_struct(_, ref fs, None) => {
               let ety = ty::expr_ty(cx.tcx, e);
               let repr = adt::represent_type(cx, ety);
               let tcx = cx.tcx;
-
-              let base_val = match *base_opt {
-                Some(base) => Some(const_expr(cx, base)),
-                None => None
-              };
-
               do expr::with_field_tys(tcx, ety, Some(e.id))
                   |discr, field_tys| {
-                  let cs: ~[ValueRef] = field_tys.iter().enumerate()
-                      .transform(|(ix, &field_ty)| {
+                  let cs = field_tys.map(|field_ty| {
                       match fs.iter().find_(|f| field_ty.ident == f.ident) {
                           Some(f) => const_expr(cx, (*f).expr),
                           None => {
-                              match base_val {
-                                Some(bv) => adt::const_get_field(cx, repr, bv, discr, ix),
-                                None => cx.tcx.sess.span_bug(e.span, "missing struct field")
-                              }
+                              cx.tcx.sess.span_bug(e.span, "missing struct field");
                           }
                       }
-                  }).collect();
+                  });
                   adt::trans_const(cx, repr, discr, cs)
               }
           }

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

@@ -19,7 +19,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, ChainIterator};
+use iterator::{Iterator, IteratorUtil, FromIterator, Chain};
 use num;
 use option::{None, Option, Some};
 use rand::RngUtil;
@@ -751,7 +751,7 @@ impl<T:Hash + Eq> HashSet<T> {
 
     /// Visit the values representing the symmetric difference
     pub fn symmetric_difference_iter<'a>(&'a self, other: &'a HashSet<T>)
-        -> ChainIterator<SetAlgebraIter<'a, T>, SetAlgebraIter<'a, T>> {
+        -> Chain<SetAlgebraIter<'a, T>, SetAlgebraIter<'a, T>> {
         self.difference_iter(other).chain_(other.difference_iter(self))
     }
 
@@ -764,7 +764,7 @@ impl<T:Hash + Eq> HashSet<T> {
 
     /// Visit the values representing the union
     pub fn union_iter<'a>(&'a self, other: &'a HashSet<T>)
-        -> ChainIterator<HashSetIterator<'a, T>, SetAlgebraIter<'a, T>> {
+        -> Chain<HashSetIterator<'a, T>, SetAlgebraIter<'a, T>> {
         self.iter().chain_(other.difference_iter(self))
     }