---

yaml
---
r: 177655
b: refs/heads/tmp
c: f9865ea
h: refs/heads/master
i:
  177653: 0988755
  177651: 59cb2c8
  177647: 9bedeb5
v: v3

Author: Jorge Aparicio

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 9fdc0effd292b097ae487ec4d927ca15102c5791
+refs/heads/tmp: f9865eac185ef2af4df661442d5d3bd2698b725f

branches/tmp/src/doc/trpl/unsafe.md

@@ -576,6 +576,10 @@ extern fn panic_fmt(args: &core::fmt::Arguments,
 #[lang = "eh_personality"] extern fn eh_personality() {}
 # #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
 # fn main() {}
+# mod std {  // for-loops
+#     pub use core::iter;
+#     pub use core::option;
+# }
 ```
 
 Note that there is one extra lang item here which differs from the examples

branches/tmp/src/libcollections/bit.rs

@@ -104,7 +104,9 @@ type MatchWords<'a> = Chain<Enumerate<Blocks<'a>>, Skip<Take<Enumerate<Repeat<u3
 
 fn reverse_bits(byte: u8) -> u8 {
     let mut result = 0;
-    for i in 0..u8::BITS {
+    // FIXME(#21245) use a for loop
+    let mut iter = 0..u8::BITS;
+    while let Some(i) = iter.next() {
         result |= ((byte >> i) & 1) << (u8::BITS - 1 - i);
     }
     result

branches/tmp/src/libcollections/btree/node.rs

@@ -271,7 +271,7 @@ impl<T> DoubleEndedIterator for RawItems<T> {
 #[unsafe_destructor]
 impl<T> Drop for RawItems<T> {
     fn drop(&mut self) {
-        for _ in *self {}
+        for _ in self.by_ref() {}
     }
 }
 
@@ -1374,9 +1374,9 @@ impl<K, V> Drop for MoveTraversalImpl<K, V> {
     fn drop(&mut self) {
         // We need to cleanup the stored values manually, as the RawItems destructor would run
         // after our deallocation.
-        for _ in self.keys {}
-        for _ in self.vals {}
-        for _ in self.edges {}
+        for _ in self.keys.by_ref() {}
+        for _ in self.vals.by_ref() {}
+        for _ in self.edges.by_ref() {}
 
         let (alignment, size) =
                 calculate_allocation_generic::<K, V>(self.capacity, self.is_leaf);

branches/tmp/src/libcollections/lib.rs

@@ -34,6 +34,8 @@
 #![feature(unicode)]
 #![feature(hash)]
 #![cfg_attr(test, feature(test))]
+// NOTE(stage0): remove after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 #[macro_use]
 extern crate core;
@@ -114,6 +116,8 @@ mod std {
     pub use core::marker;   // derive(Copy)
     pub use core::hash;     // derive(Hash)
     pub use core::ops;      // RangeFull
+    // for-loops
+    pub use core::iter;
 }
 
 #[cfg(test)]

branches/tmp/src/libcollections/ring_buf.rs

@@ -1510,7 +1510,7 @@ pub struct Drain<'a, T: 'a> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T: 'a> Drop for Drain<'a, T> {
     fn drop(&mut self) {
-        for _ in *self {}
+        for _ in self.by_ref() {}
         self.inner.head = 0;
         self.inner.tail = 0;
     }
@@ -1793,7 +1793,9 @@ mod tests {
     fn bench_push_back_100(b: &mut test::Bencher) {
         let mut deq = RingBuf::with_capacity(101);
         b.iter(|| {
-            for i in 0i..100 {
+            // FIXME(#21245) use a for loop
+            let mut iter = 0i..100;
+            while let Some(i) = iter.next() {
                 deq.push_back(i);
             }
             deq.head = 0;
@@ -1805,7 +1807,9 @@ mod tests {
     fn bench_push_front_100(b: &mut test::Bencher) {
         let mut deq = RingBuf::with_capacity(101);
         b.iter(|| {
-            for i in 0i..100 {
+            // FIXME(#21245) use a for loop
+            let mut iter = 0i..100;
+            while let Some(i) = iter.next() {
                 deq.push_front(i);
             }
             deq.head = 0;

branches/tmp/src/libcollections/slice.rs

@@ -1958,7 +1958,7 @@ mod tests {
             let mut amt = 0;
             let mut it = v.permutations();
             let (min_size, max_opt) = it.size_hint();
-            for _perm in it {
+            for _perm in it.by_ref() {
                 amt += 1;
             }
             assert_eq!(amt, it.swaps.swaps_made);

branches/tmp/src/libcollections/str.rs

@@ -279,7 +279,7 @@ impl<'a> Iterator for Recompositions<'a> {
         loop {
             match self.state {
                 Composing => {
-                    for ch in self.iter {
+                    for ch in self.iter.by_ref() {
                         let ch_class = unicode::char::canonical_combining_class(ch);
                         if self.composee.is_none() {
                             if ch_class != 0 {

branches/tmp/src/libcollections/vec.rs

@@ -1567,7 +1567,9 @@ impl<T> Drop for Vec<T> {
         // zeroed (when moving out, because of #[unsafe_no_drop_flag]).
         if self.cap != 0 {
             unsafe {
-                for x in self.iter() {
+                // FIXME(#21245) use a for loop
+                let mut iter = self.iter();
+                while let Some(x) = iter.next() {
                     ptr::read(x);
                 }
                 dealloc(*self.ptr, self.cap)
@@ -1648,7 +1650,7 @@ impl<T> IntoIter<T> {
     #[unstable(feature = "collections")]
     pub fn into_inner(mut self) -> Vec<T> {
         unsafe {
-            for _x in self { }
+            for _x in self.by_ref() { }
             let IntoIter { allocation, cap, ptr: _ptr, end: _end } = self;
             mem::forget(self);
             Vec { ptr: NonZero::new(allocation), cap: cap, len: 0 }
@@ -1726,7 +1728,7 @@ impl<T> Drop for IntoIter<T> {
     fn drop(&mut self) {
         // destroy the remaining elements
         if self.cap != 0 {
-            for _x in *self {}
+            for _x in self.by_ref() {}
             unsafe {
                 dealloc(self.allocation, self.cap);
             }
@@ -1816,7 +1818,7 @@ impl<'a, T> Drop for Drain<'a, T> {
         // so we can use #[unsafe_no_drop_flag].
 
         // destroy the remaining elements
-        for _x in *self {}
+        for _x in self.by_ref() {}
     }
 }
 

branches/tmp/src/libcore/iter.rs

@@ -195,7 +195,7 @@ pub trait IteratorExt: Iterator + Sized {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
-        for x in *self {
+        for x in self.by_ref() {
             if n == 0 { return Some(x) }
             n -= 1;
         }
@@ -492,7 +492,7 @@ pub trait IteratorExt: Iterator + Sized {
     /// fn process<U: Iterator<Item=isize>>(it: U) -> isize {
     ///     let mut it = it.fuse();
     ///     let mut sum = 0;
-    ///     for x in it {
+    ///     for x in it.by_ref() {
     ///         if x > 5 {
     ///             break;
     ///         }
@@ -660,7 +660,7 @@ pub trait IteratorExt: Iterator + Sized {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
-        for x in *self { if f(x) { return true; } }
+        for x in self.by_ref() { if f(x) { return true; } }
         false
     }
 
@@ -680,7 +680,7 @@ pub trait IteratorExt: Iterator + Sized {
     fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
         P: FnMut(&Self::Item) -> bool,
     {
-        for x in *self {
+        for x in self.by_ref() {
             if predicate(&x) { return Some(x) }
         }
         None
@@ -703,7 +703,7 @@ pub trait IteratorExt: Iterator + Sized {
         P: FnMut(Self::Item) -> bool,
     {
         let mut i = 0;
-        for x in *self {
+        for x in self.by_ref() {
             if predicate(x) {
                 return Some(i);
             }
@@ -1664,7 +1664,7 @@ impl<A, I, P> Iterator for Filter<A, I, P> where I: Iterator<Item=A>, P: FnMut(&
 
     #[inline]
     fn next(&mut self) -> Option<A> {
-        for x in self.iter {
+        for x in self.iter.by_ref() {
             if (self.predicate)(&x) {
                 return Some(x);
             } else {
@@ -1728,7 +1728,7 @@ impl<A, B, I, F> Iterator for FilterMap<A, B, I, F> where
 
     #[inline]
     fn next(&mut self) -> Option<B> {
-        for x in self.iter {
+        for x in self.iter.by_ref() {
             match (self.f)(x) {
                 Some(y) => return Some(y),
                 None => ()
@@ -1914,7 +1914,7 @@ impl<A, I, P> Iterator for SkipWhile<A, I, P> where I: Iterator<Item=A>, P: FnMu
 
     #[inline]
     fn next(&mut self) -> Option<A> {
-        for x in self.iter {
+        for x in self.iter.by_ref() {
             if self.flag || !(self.predicate)(&x) {
                 self.flag = true;
                 return Some(x);
@@ -2207,7 +2207,7 @@ impl<A, B, I, U, F> Iterator for FlatMap<A, B, I, U, F> where
     fn next(&mut self) -> Option<B> {
         loop {
             for inner in self.frontiter.iter_mut() {
-                for x in *inner {
+                for x in inner.by_ref() {
                     return Some(x)
                 }
             }

branches/tmp/src/libcore/lib.rs

@@ -65,6 +65,8 @@
 #![allow(unknown_features)] #![feature(int_uint)]
 #![feature(on_unimplemented)]
 #![deny(missing_docs)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 #[macro_use]
 mod macros;
@@ -158,4 +160,6 @@ mod std {
     pub use marker;
     pub use ops;
     pub use option;
+    // for-loops
+    pub use iter;
 }

branches/tmp/src/libcore/num/mod.rs

@@ -1524,7 +1524,7 @@ macro_rules! from_str_radix_float_impl {
                 let mut exp_info = None::<(char, uint)>;
 
                 // Parse the integer part of the significand
-                for (i, c) in cs {
+                for (i, c) in cs.by_ref() {
                     match c.to_digit(radix) {
                         Some(digit) => {
                             // shift significand one digit left
@@ -1572,7 +1572,7 @@ macro_rules! from_str_radix_float_impl {
                 // part of the significand
                 if exp_info.is_none() {
                     let mut power = 1.0;
-                    for (i, c) in cs {
+                    for (i, c) in cs.by_ref() {
                         match c.to_digit(radix) {
                             Some(digit) => {
                                 // Decrease power one order of magnitude

branches/tmp/src/librand/lib.rs

@@ -498,6 +498,8 @@ mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone
     pub use core::marker;
+    // for-loops
+    pub use core::iter;
 }
 
 #[cfg(test)]

branches/tmp/src/librustc/lib.rs

@@ -41,6 +41,9 @@
 #![feature(unicode)]
 #![feature(hash)]
 #![cfg_attr(test, feature(test))]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 extern crate arena;
 extern crate flate;

branches/tmp/src/librustc/middle/dataflow.rs

@@ -352,7 +352,9 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
         for (word_index, &word) in words.iter().enumerate() {
             if word != 0 {
                 let base_index = word_index * uint::BITS;
-                for offset in 0u..uint::BITS {
+                // FIXME(#21245) use a for loop
+                let mut iter = 0u..uint::BITS;
+                while let Some(offset) = iter.next() {
                     let bit = 1 << offset;
                     if (word & bit) != 0 {
                         // NB: we round up the total number of bits

branches/tmp/src/librustc_trans/lib.rs

@@ -41,6 +41,9 @@
 #![feature(std_misc)]
 #![feature(unicode)]
 #![feature(hash)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 extern crate arena;
 extern crate flate;

branches/tmp/src/librustc_typeck/lib.rs

@@ -84,6 +84,9 @@ This API is completely unstable and subject to change.
 #![feature(core)]
 #![feature(rustc_private)]
 #![feature(std_misc)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;

branches/tmp/src/librustdoc/lib.rs

@@ -32,6 +32,9 @@
 #![feature(test)]
 #![feature(unicode)]
 #![feature(hash)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 extern crate arena;
 extern crate getopts;

branches/tmp/src/libserialize/collection_impls.rs

@@ -148,7 +148,9 @@ impl<
     fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {
         let bits = try!(d.read_uint());
         let mut set = EnumSet::new();
-        for bit in 0..uint::BITS {
+        // FIXME(#21245) use a for loop
+        let mut iter = 0..uint::BITS;
+        while let Some(bit) = iter.next() {
             if bits & (1 << bit) != 0 {
                 set.insert(CLike::from_uint(1 << bit));
             }

branches/tmp/src/libstd/ascii.rs

@@ -232,7 +232,10 @@ pub fn escape_default<F>(c: u8, mut f: F) where
         _ => {
             f(b'\\');
             f(b'x');
-            for &offset in [4u, 0u].iter() {
+            // FIXME(#21245) use a for loop
+            let arr = [4u, 0u];
+            let mut iter = arr.iter();
+            while let ::option::Option::Some(&offset) = ::iter::Iterator::next(&mut iter) {
                 match ((c as i32) >> offset) & 0xf {
                     i @ 0 ... 9 => f(b'0' + (i as u8)),
                     i => f(b'a' + (i as u8 - 10)),

branches/tmp/src/libstd/collections/hash/table.rs

@@ -15,7 +15,7 @@ use self::BucketState::*;
 use clone::Clone;
 use cmp;
 use hash::{Hash, Hasher};
-use iter::{Iterator, ExactSizeIterator, count};
+use iter::{Iterator, IteratorExt, ExactSizeIterator, count};
 use marker::{Copy, Sized, self};
 use mem::{min_align_of, size_of};
 use mem;
@@ -921,7 +921,7 @@ impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
 #[unsafe_destructor]
 impl<'a, K: 'a, V: 'a> Drop for Drain<'a, K, V> {
     fn drop(&mut self) {
-        for _ in *self {}
+        for _ in self.by_ref() {}
     }
 }
 

branches/tmp/src/libstd/lib.rs

@@ -123,6 +123,9 @@
 #![feature(rand)]
 #![feature(hash)]
 #![cfg_attr(test, feature(test))]
+#![allow(unstable)]
+// NOTE(stage0): remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
 
 // Don't link to std. We are std.
 #![no_std]
@@ -310,4 +313,6 @@ mod std {
     pub use slice;
 
     pub use boxed; // used for vec![]
+    // for-loops
+    pub use iter;
 }

branches/tmp/src/libstd/path/windows.rs

@@ -557,7 +557,7 @@ impl GenericPath for Path {
                     }
                     (Some(a), Some(_)) => {
                         comps.push("..");
-                        for _ in itb {
+                        for _ in itb.by_ref() {
                             comps.push("..");
                         }
                         comps.push(a);