---

yaml
---
r: 178494
b: refs/heads/try
c: 44ff721
h: refs/heads/master
v: v3

Author: richo

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 336c8d2e9c6b276b162bdb3edd43706372e6eddd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 474b324eda10440d6568ef872a7307d38e7de95b
-refs/heads/try: 9ff540ba3771a1c0a396ca3f7a685a94b4e0f622
+refs/heads/try: 44ff72195e0a5a3b0bfd4b8b3cef919cfa9661ef
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

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

@@ -576,10 +576,6 @@ 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/try/src/libcollections/binary_heap.rs

@@ -153,7 +153,7 @@
 use core::prelude::*;
 
 use core::default::Default;
-use core::iter::{FromIterator, IntoIterator};
+use core::iter::FromIterator;
 use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
@@ -655,22 +655,6 @@ impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     }
 }
 
-impl<T: Ord> IntoIterator for BinaryHeap<T> {
-    type Iter = IntoIter<T>;
-
-    fn into_iter(self) -> IntoIter<T> {
-        self.into_iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a BinaryHeap<T> where T: Ord {
-    type Iter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Extend<T> for BinaryHeap<T> {
     fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {

branches/try/src/libcollections/bit.rs

@@ -89,7 +89,7 @@ use core::fmt;
 use core::hash;
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
-use core::iter::{self, FromIterator, IntoIterator};
+use core::iter::{self, FromIterator};
 use core::num::Int;
 use core::ops::Index;
 use core::slice;
@@ -1070,14 +1070,6 @@ impl<'a> RandomAccessIterator for Iter<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a Bitv {
-    type Iter = Iter<'a>;
-
-    fn into_iter(self) -> Iter<'a> {
-        self.iter()
-    }
-}
-
 /// An implementation of a set using a bit vector as an underlying
 /// representation for holding unsigned numerical elements.
 ///
@@ -1881,13 +1873,6 @@ impl<'a> Iterator for SymmetricDifference<'a> {
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
 
-impl<'a> IntoIterator for &'a BitvSet {
-    type Iter = SetIter<'a>;
-
-    fn into_iter(self) -> SetIter<'a> {
-        self.iter()
-    }
-}
 
 #[cfg(test)]
 mod tests {

branches/try/src/libcollections/btree/map.rs

@@ -24,7 +24,7 @@ use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
-use core::iter::{Map, FromIterator, IntoIterator};
+use core::iter::{Map, FromIterator};
 use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem};
 use Bound::{self, Included, Excluded, Unbounded};
@@ -478,30 +478,6 @@ impl<K: Ord, V> BTreeMap<K, V> {
     }
 }
 
-impl<K, V> IntoIterator for BTreeMap<K, V> {
-    type Iter = IntoIter<K, V>;
-
-    fn into_iter(self) -> IntoIter<K, V> {
-        self.into_iter()
-    }
-}
-
-impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {
-    type Iter = Iter<'a, K, V>;
-
-    fn into_iter(self) -> Iter<'a, K, V> {
-        self.iter()
-    }
-}
-
-impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V> {
-    type Iter = IterMut<'a, K, V>;
-
-    fn into_iter(mut self) -> IterMut<'a, K, V> {
-        self.iter_mut()
-    }
-}
-
 /// A helper enum useful for deciding whether to continue a loop since we can't
 /// return from a closure
 enum Continuation<A, B> {

branches/try/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.by_ref() {}
+        for _ in *self {}
     }
 }
 
@@ -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.by_ref() {}
-        for _ in self.vals.by_ref() {}
-        for _ in self.edges.by_ref() {}
+        for _ in self.keys {}
+        for _ in self.vals {}
+        for _ in self.edges {}
 
         let (alignment, size) =
                 calculate_allocation_generic::<K, V>(self.capacity, self.is_leaf);

branches/try/src/libcollections/btree/set.rs

@@ -18,7 +18,7 @@ use core::cmp::Ordering::{self, Less, Greater, Equal};
 use core::default::Default;
 use core::fmt::Debug;
 use core::fmt;
-use core::iter::{Peekable, Map, FromIterator, IntoIterator};
+use core::iter::{Peekable, Map, FromIterator};
 use core::ops::{BitOr, BitAnd, BitXor, Sub};
 
 use btree_map::{BTreeMap, Keys};
@@ -480,22 +480,6 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
     }
 }
 
-impl<T> IntoIterator for BTreeSet<T> {
-    type Iter = IntoIter<T>;
-
-    fn into_iter(self) -> IntoIter<T> {
-        self.into_iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a BTreeSet<T> {
-    type Iter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Extend<T> for BTreeSet<T> {
     #[inline]

branches/try/src/libcollections/dlist.rs

@@ -28,7 +28,7 @@ use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
 use core::hash::{Writer, Hasher, Hash};
-use core::iter::{self, FromIterator, IntoIterator};
+use core::iter::{self, FromIterator};
 use core::mem;
 use core::ptr;
 
@@ -830,30 +830,6 @@ impl<A> FromIterator<A> for DList<A> {
     }
 }
 
-impl<T> IntoIterator for DList<T> {
-    type Iter = IntoIter<T>;
-
-    fn into_iter(self) -> IntoIter<T> {
-        self.into_iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a DList<T> {
-    type Iter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a mut DList<T> {
-    type Iter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> Extend<A> for DList<A> {
     fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {

branches/try/src/libcollections/enum_set.rs

@@ -16,7 +16,7 @@
 use core::prelude::*;
 use core::fmt;
 use core::num::Int;
-use core::iter::{FromIterator, IntoIterator};
+use core::iter::FromIterator;
 use core::ops::{Sub, BitOr, BitAnd, BitXor};
 
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
@@ -256,14 +256,6 @@ impl<E:CLike> FromIterator<E> for EnumSet<E> {
     }
 }
 
-impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {
-    type Iter = Iter<E>;
-
-    fn into_iter(self) -> Iter<E> {
-        self.iter()
-    }
-}
-
 impl<E:CLike> Extend<E> for EnumSet<E> {
     fn extend<I: Iterator<Item=E>>(&mut self, mut iterator: I) {
         for element in iterator {

branches/try/src/libcollections/lib.rs

@@ -34,8 +34,6 @@
 #![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;
@@ -113,11 +111,8 @@ mod std {
     pub use core::option;   // necessary for panic!()
     pub use core::clone;    // derive(Clone)
     pub use core::cmp;      // derive(Eq, Ord, etc.)
-    pub use core::marker;   // derive(Copy)
+    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/try/src/libcollections/ring_buf.rs

@@ -19,7 +19,7 @@ use core::prelude::*;
 use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
-use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator};
+use core::iter::{self, repeat, FromIterator, RandomAccessIterator};
 use core::marker;
 use core::mem;
 use core::num::{Int, UnsignedInt};
@@ -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.by_ref() {}
+        for _ in *self {}
         self.inner.head = 0;
         self.inner.tail = 0;
     }
@@ -1609,30 +1609,6 @@ impl<A> FromIterator<A> for RingBuf<A> {
     }
 }
 
-impl<T> IntoIterator for RingBuf<T> {
-    type Iter = IntoIter<T>;
-
-    fn into_iter(self) -> IntoIter<T> {
-        self.into_iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a RingBuf<T> {
-    type Iter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a mut RingBuf<T> {
-    type Iter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> Extend<A> for RingBuf<A> {
     fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {

branches/try/src/libcollections/slice.rs

@@ -98,10 +98,7 @@ use core::iter::{range_step, MultiplicativeIterator};
 use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
-#[cfg(stage0)]
 use core::ops::{FnMut, FullRange};
-#[cfg(not(stage0))]
-use core::ops::FnMut;
 use core::option::Option::{self, Some, None};
 use core::ptr::PtrExt;
 use core::ptr;
@@ -1512,10 +1509,7 @@ mod tests {
     use core::prelude::{Some, None, range, Clone};
     use core::prelude::{Iterator, IteratorExt};
     use core::prelude::{AsSlice};
-    #[cfg(stage0)]
     use core::prelude::{Ord, FullRange};
-    #[cfg(not(stage0))]
-    use core::prelude::Ord;
     use core::default::Default;
     use core::mem;
     use std::iter::RandomAccessIterator;
@@ -1958,7 +1952,7 @@ mod tests {
             let mut amt = 0;
             let mut it = v.permutations();
             let (min_size, max_opt) = it.size_hint();
-            for _perm in it.by_ref() {
+            for _perm in it {
                 amt += 1;
             }
             assert_eq!(amt, it.swaps.swaps_made);