---

yaml
---
r: 56206
b: refs/heads/auto
c: 5dda8ab
h: refs/heads/master
v: v3

Author: intgr

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d32d4d12096dc39ff428f606e2242eaae0c6a0de
+refs/heads/auto: 5dda8ab12999d6f434a6d5f3746b48b757acb7b7
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/vec.rs

@@ -18,10 +18,6 @@ use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use clone::Clone;
 use iter::BaseIter;
 use iter;
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
-use iterator::Iterator;
 use kinds::Copy;
 use libc;
 use option::{None, Option, Some};
@@ -1923,7 +1919,6 @@ impl<'self,T> ImmutableVector<T> for &'self [T] {
 #[cfg(stage3)]
 pub trait ImmutableVector<'self, T> {
     fn slice(&self, start: uint, end: uint) -> &'self [T];
-    fn iter(self) -> VecIterator<'self, T>;
     fn head(&self) -> &'self T;
     fn head_opt(&self) -> Option<&'self T>;
     fn tail(&self) -> &'self [T];
@@ -1954,15 +1949,6 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
         slice(*self, start, end)
     }
 
-    #[inline]
-    fn iter(self) -> VecIterator<'self, T> {
-        unsafe {
-            let p = vec::raw::to_ptr(self);
-            VecIterator{ptr: p, end: p.offset(self.len()),
-                        lifetime: cast::transmute(p)}
-        }
-    }
-
     /// Returns the first element of a vector, failing if the vector is empty.
     #[inline]
     fn head(&self) -> &'self T { head(*self) }
@@ -2809,33 +2795,7 @@ impl<A:Clone> Clone for ~[A] {
     }
 }
 
-// could be implemented with &[T] with .slice(), but this avoids bounds checks
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
-pub struct VecIterator<'self, T> {
-    priv ptr: *T,
-    priv end: *T,
-    priv lifetime: &'self T // FIXME: #5922
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
-impl<'self, T> Iterator<&'self T> for VecIterator<'self, T> {
-    #[inline]
-    fn next(&mut self) -> Option<&'self T> {
-        unsafe {
-            if self.ptr == self.end {
-                None
-            } else {
-                let old = self.ptr;
-                self.ptr = self.ptr.offset(1);
-                Some(cast::transmute(old))
-            }
-        }
-    }
-}
+// ___________________________________________________________________________
 
 #[cfg(test)]
 mod tests {
@@ -4461,19 +4421,6 @@ mod tests {
         [1, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
         [2, 2].cmp(& &[1, 2, 3, 4]) == Greater;
     }
-
-    #[test]
-    fn test_iterator() {
-        use iterator::*;
-        let xs = [1, 2, 5, 10, 11];
-        let ys = [1, 2, 5, 10, 11, 19];
-        let mut it = xs.iter();
-        let mut i = 0;
-        for it.advance |&x| {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-    }
 }
 
 // Local Variables:

branches/auto/src/rt/rust_exchange_alloc.cpp

@@ -48,8 +48,8 @@ rust_get_exchange_count_ptr() {
 void
 rust_check_exchange_count_on_exit() {
   if (exchange_count != 0) {
-    printf("exchange heap not empty on on exit");
-    printf("%d dangling allocations", (int)exchange_count);
+    printf("exchange heap not empty on exit\n");
+    printf("%d dangling allocations\n", (int)exchange_count);
     abort();
   }
 }