---

yaml
---
r: 68351
b: refs/heads/auto
c: 32adc0e
h: refs/heads/master
i:
  68349: 52053a8
  68347: 74f2a69
  68343: 1320b7d
  68335: d7012a5
  68319: 21c2ca4
  68287: 4daad7f
  68223: 9663677
  68095: a574a6a
v: v3

Author: bors

[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: 3df37326cf880425625373f3e11f74afac4dbb67
+refs/heads/auto: 32adc0e730636f04d72d31e24fbf1101a495ccb7
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/.gitmodules

@@ -1,8 +1,6 @@
 [submodule "src/llvm"]
 	path = src/llvm
 	url = https://github.com/brson/llvm.git
-	branch = master
 [submodule "src/libuv"]
 	path = src/libuv
 	url = https://github.com/brson/libuv.git
-	branch = master

branches/auto/RELEASES.txt

@@ -4,8 +4,6 @@ Version 0.7 (July 2013)
    * ??? changes, numerous bugfixes
 
    * Syntax changes
-      * `impl`s no longer accept a visibility qualifier. Put them on methods
-        instead.
       * `use mod` is no longer valid.
       * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style
         argument list.
@@ -27,10 +25,6 @@ Version 0.7 (July 2013)
         no padding between fields.
       * The `for` loop protocol now requires `for`-iterators to return `bool`
         so they compose better.
-      * Trait default methods work more often.
-      * Type parameters bound by `Copy` must now be copied explicitly with
-        the `copy` keyword.
-      * It is now illegal to move out of a dereferenced unsafe pointer.
       * `Option<~T>` is now represented as a nullable pointer.
       * `@mut` does dynamic borrow checks correctly.
       * Macros TODO
@@ -49,30 +43,26 @@ Version 0.7 (July 2013)
    * Libraries
       * The `core` crate was renamed to `std`.
       * The `std` crate was renamed to `extra`.
-      * std: `iterator` module for external iterator objects.
-      * Many old-style (internal, higher-order function) iterators replaced by
-        implementations of `Iterator`.
-      * std: Many old internal vector and string iterators,
-        incl. `any`, `all`. removed.
-      * std: The `finalize` method of `Drop` renamed to `drop`.
+      * `std::mut` removed.
       * std: The prelude no longer reexports any modules, only types and traits.
       * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`,
         `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits.
-      * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`,
+      * std: `iterator` module for external iterator objects.
+      * std: Many old internal vector and string iterators,
+        incl. `any`, `all`. removed.
+      * std: new numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`,
         `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`.
       * std: Tuple traits and accessors defined for up to 12-tuples, e.g.
         `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`.
-      * std: Many types implement `Clone`.
+      * std: many types implement `Clone`.
       * std: `path` type renamed to `Path`.
-      * std: `mut` module and `Mut` type removed.
       * std: Many standalone functions removed in favor of methods and iterators
         in `vec`, `str`. In the future methods will also work as functions.
-      * std: `reinterpret_cast` removed. Use `transmute`.
+      * std: `reinterpret_cast` removed. Used `transmute`.
       * std: ascii string handling in `std::ascii`.
       * std: `Rand` is implemented for ~/@.
       * std: `run` module for spawning processes overhauled.
       * std: Various atomic types added to `unstable::atomic`.
-      * std: Various types implement `Zero`.
       * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`.
       * std: Borrowed pointer functions moved from `ptr` to `borrow`.
       * std: Added `os::mkdir_recursive`.
@@ -106,6 +96,7 @@ Version 0.7 (July 2013)
       * More and improved library documentation.
       * Various improvements on ARM and Android.
       * Various improvements to MIPS backend.
+      * jemalloc is the Rust allocator.
 
 Version 0.6 (April 2013)
 ------------------------

branches/auto/src/etc/combine-tests.py

@@ -60,7 +60,7 @@ def scrub(b):
 for t in stage2_tests:
     p = os.path.join("test", "run-pass", t)
     p = p.replace("\\", "\\\\")
-    d.write("    out.write_str(\"run-pass [stage2]: %s\\n\");\n" % p)
+    d.write("    out.write_str(~\"run-pass [stage2]: %s\\n\");\n" % p)
     d.write("    t_%d::main();\n" % i)
     i += 1
 d.write("}\n")

branches/auto/src/libextra/deque.rs

@@ -9,12 +9,12 @@
 // except according to those terms.
 
 //! A double-ended queue implemented as a circular buffer
+
 use core::prelude::*;
 
 use core::uint;
 use core::util::replace;
 use core::vec;
-use core::cast::transmute;
 
 static initial_capacity: uint = 32u; // 2^5
 
@@ -153,86 +153,7 @@ impl<T> Deque<T> {
     pub fn reserve_at_least(&mut self, n: uint) {
         vec::reserve_at_least(&mut self.elts, n);
     }
-
-    /// Front-to-back iterator.
-    pub fn iter<'a>(&'a self) -> DequeIterator<'a, T> {
-    DequeIterator { idx: self.lo, nelts: self.nelts, used: 0, vec: self.elts }
-    }
-    
-    /// Front-to-back iterator which returns mutable values.
-    pub fn mut_iter<'a>(&'a mut self) -> DequeMutIterator<'a, T> {
-    DequeMutIterator { idx: self.lo, nelts: self.nelts, used: 0, vec: self.elts }
-    }
-
-    /// Back-to-front iterator.
-    pub fn rev_iter<'a>(&'a self) -> DequeRevIterator<'a, T> {
-    DequeRevIterator { idx: self.hi - 1u, nelts: self.nelts, used: 0, vec: self.elts }
-    }
-
-    /// Back-to-front iterator which returns mutable values.
-    pub fn mut_rev_iter<'a>(&'a mut self) -> DequeMutRevIterator<'a, T> {
-    DequeMutRevIterator { idx: self.hi - 1u, nelts: self.nelts, used: 0, vec: self.elts }
-    }
-}
-
-macro_rules! iterator {
-    (impl $name:ident -> $elem:ty, $step:expr) => {
-        impl<'self, T> Iterator<$elem> for $name<'self, T> {
-            #[inline]
-            fn next(&mut self) -> Option<$elem> {
-                if self.used >= self.nelts {
-                    return None;
-                }
-                let ret = unsafe { 
-                    match self.vec[self.idx % self.vec.len()] {
-                        Some(ref e) => Some(transmute(e)),
-                        None => None
-                    }
-                };
-                self.idx += $step;
-                self.used += 1;
-                ret
-            }
-        }
-    }
-}
-
-/// Deque iterator
-pub struct DequeIterator<'self, T> {
-    priv idx: uint,
-    priv nelts: uint,
-    priv used: uint,
-    priv vec: &'self [Option<T>]
-}
-iterator!{impl DequeIterator -> &'self T, 1}
-
-/// Deque reverse iterator
-pub struct DequeRevIterator<'self, T> {
-    priv idx: uint,
-    priv nelts: uint,
-    priv used: uint,
-    priv vec: &'self [Option<T>]
 }
-iterator!{impl DequeRevIterator -> &'self T, -1}
-
-/// Deque mutable iterator
-pub struct DequeMutIterator<'self, T> {
-    priv idx: uint,
-    priv nelts: uint,
-    priv used: uint,
-    priv vec: &'self mut [Option<T>]
-
-}
-iterator!{impl DequeMutIterator -> &'self mut T, 1}
-
-/// Deque mutable reverse iterator
-pub struct DequeMutRevIterator<'self, T> {
-    priv idx: uint,
-    priv nelts: uint,
-    priv used: uint,
-    priv vec: &'self mut [Option<T>]
-}
-iterator!{impl DequeMutRevIterator -> &'self mut T, -1}
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
 /// elsewhere.
@@ -461,35 +382,4 @@ mod tests {
         assert_eq!(capacity(&mut d.elts), 64);
     }
 
-    #[test]
-    fn test_iter() {
-        let mut d = Deque::new();
-        for std::int::range(0,5) |i| {
-            d.add_back(i);
-        }
-        assert_eq!(d.iter().collect::<~[&int]>(),
-           ~[&0,&1,&2,&3,&4]);
-        
-        for std::int::range(6,9) |i| {
-            d.add_front(i);
-        }
-        assert_eq!(d.iter().collect::<~[&int]>(),
-            ~[&8,&7,&6,&0,&1,&2,&3,&4]);
-    }
-
-    #[test]
-    fn test_rev_iter() {
-        let mut d = Deque::new();
-        for std::int::range(0,5) |i| {
-            d.add_back(i);
-        }
-        assert_eq!(d.rev_iter().collect::<~[&int]>(),
-           ~[&4,&3,&2,&1,&0]);
-        
-        for std::int::range(6,9) |i| {
-            d.add_front(i);
-        }
-        assert_eq!(d.rev_iter().collect::<~[&int]>(),
-            ~[&4,&3,&2,&1,&0,&6,&7,&8]);
-    }
 }

branches/auto/src/libextra/priority_queue.rs

@@ -37,11 +37,10 @@ impl<T:Ord> Mutable for PriorityQueue<T> {
 }
 
 impl<T:Ord> PriorityQueue<T> {
-    /// An iterator visiting all values in underlying vector, in
-    /// arbitrary order.
-    pub fn iter<'a>(&'a self) -> PriorityQueueIterator<'a, T> {
-        PriorityQueueIterator { iter: self.data.iter() }
-    }
+    /// Visit all values in the underlying vector.
+    ///
+    /// The values are **not** visited in order.
+    pub fn each(&self, f: &fn(&T) -> bool) -> bool { self.data.iter().advance(f) }
 
     /// Returns the greatest item in the queue - fails if empty
     pub fn top<'a>(&'a self) -> &'a T { &self.data[0] }
@@ -179,33 +178,11 @@ impl<T:Ord> PriorityQueue<T> {
     }
 }
 
-/// PriorityQueue iterator
-pub struct PriorityQueueIterator <'self, T> {
-    priv iter: vec::VecIterator<'self, T>,
-}
-
-impl<'self, T> Iterator<&'self T> for PriorityQueueIterator<'self, T> {
-    #[inline]
-    fn next(&mut self) -> Option<(&'self T)> { self.iter.next() }
-}
-
 #[cfg(test)]
 mod tests {
     use sort::merge_sort;
     use priority_queue::PriorityQueue;
 
-    #[test]
-    fn test_iterator() {
-        let data = ~[5, 9, 3];
-        let iterout = ~[9, 5, 3];
-        let pq = PriorityQueue::from_vec(data);
-        let mut i = 0;
-        for pq.iter().advance |el| {
-            assert_eq!(*el, iterout[i]);
-            i += 1;
-        }
-    }
-
     #[test]
     fn test_top_and_pop() {
         let data = ~[2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];