---

yaml
---
r: 156460
b: refs/heads/snap-stage3
c: 555ab2b
h: refs/heads/master
v: v3

Author: cakebaker

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7d0cc44f873ac338b400b20bcb62618aa5d36b70
+refs/heads/snap-stage3: 555ab2b3a4b25ea9285ca65350e248443f1945ac
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/crates.mk

@@ -49,11 +49,11 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std green native flate arena term \
-                 serialize sync getopts collections test time rand \
-                 log regex graphviz core rbml rlibc alloc rustrt \
+TARGET_CRATES := libc std green native flate arena glob term semver \
+                 uuid serialize sync getopts collections num test time rand \
+                 url log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
-HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -83,13 +83,18 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
+DEPS_semver := std
+DEPS_uuid := std serialize
 DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
+DEPS_fourcc := rustc syntax std
+DEPS_hexfloat := rustc syntax std
 DEPS_num := std
 DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers
 DEPS_time := std serialize
 DEPS_rand := core
+DEPS_url := std
 DEPS_log := std regex
 DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex

branches/snap-stage3/src/doc/guide.md

@@ -3095,10 +3095,10 @@ And try to run the test:
 
 ```{notrust,ignore}
 $ cargo test
-   Compiling testing v0.0.1 (file:///home/you/projects/testing)
-/home/you/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
-/home/you/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
-                                                           ^~~~~~~~~~~~~~~~~~~~
+   Compiling testing v0.0.1 (file:///home/youg/projects/testing)
+/home/youg/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
+/home/youg/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
+                                                            ^~~~~~~~~~~~~~~~~~~~
 error: aborting due to previous error
 Build failed, waiting for other jobs to finish...
 Could not compile `testing`.
@@ -3284,11 +3284,11 @@ Let's give it a shot:
 $ cargo test
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
 
-running 1 test
+running 2 tests
 test test::test_times_four ... ok
 test test::test_add_three ... ok
 
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
 
 
 running 0 tests

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

@@ -475,6 +475,12 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
+    /// Deprecated: use `iter_mut`.
+    #[deprecated = "use iter_mut"]
+    pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
+        self.iter_mut()
+    }
+
     /// Provides a forward iterator with mutable references.
     #[inline]
     pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
@@ -490,6 +496,12 @@ impl<T> DList<T> {
         }
     }
 
+    /// Deprecated: use `into_iter`.
+    #[deprecated = "use into_iter"]
+    pub fn move_iter(self) -> MoveItems<T> {
+        self.into_iter()
+    }
+
     /// Consumes the list into an iterator yielding elements by value.
     #[inline]
     pub fn into_iter(self) -> MoveItems<T> {
@@ -858,8 +870,7 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.append(list_from(u.as_slice()));
         check_links(&m);
-        let mut sum = v;
-        sum.push_all(u.as_slice());
+        let sum = v.append(u.as_slice());
         assert_eq!(sum.len(), m.len());
         for elt in sum.into_iter() {
             assert_eq!(m.pop_front(), Some(elt))

branches/snap-stage3/src/libcollections/lib.rs

@@ -502,6 +502,40 @@ pub trait Deque<T> : MutableSeq<T> {
     /// ```
     fn push_front(&mut self, elt: T);
 
+    /// Inserts an element last in the sequence.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{DList, Deque};
+    ///
+    /// let mut d = DList::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    /// assert_eq!(d.front(), Some(&1i));
+    /// ```
+    #[deprecated = "use the `push` method"]
+    fn push_back(&mut self, elt: T) { self.push(elt) }
+
+    /// Removes the last element and returns it, or `None` if the sequence is
+    /// empty.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{RingBuf, Deque};
+    ///
+    /// let mut d = RingBuf::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    ///
+    /// assert_eq!(d.pop_back(), Some(2i));
+    /// assert_eq!(d.pop_back(), Some(1i));
+    /// assert_eq!(d.pop_back(), None);
+    /// ```
+    #[deprecated = "use the `pop` method"]
+    fn pop_back(&mut self) -> Option<T> { self.pop() }
+
     /// Removes the first element and returns it, or `None` if the sequence is
     /// empty.
     ///

branches/snap-stage3/src/libcollections/priority_queue.rs

@@ -269,6 +269,9 @@ impl<T: Ord> PriorityQueue<T> {
         if self.is_empty() { None } else { Some(&self.data[0]) }
     }
 
+    #[deprecated="renamed to `top`"]
+    pub fn maybe_top<'a>(&'a self) -> Option<&'a T> { self.top() }
+
     /// Returns the number of elements the queue can hold without reallocating.
     ///
     /// # Example
@@ -338,6 +341,9 @@ impl<T: Ord> PriorityQueue<T> {
         }
     }
 
+    #[deprecated="renamed to `pop`"]
+    pub fn maybe_pop(&mut self) -> Option<T> { self.pop() }
+
     /// Pushes an item onto the queue.
     ///
     /// # Example
@@ -411,6 +417,14 @@ impl<T: Ord> PriorityQueue<T> {
         }
     }
 
+    #[allow(dead_code)]
+    #[deprecated="renamed to `into_vec`"]
+    fn to_vec(self) -> Vec<T> { self.into_vec() }
+
+    #[allow(dead_code)]
+    #[deprecated="renamed to `into_sorted_vec`"]
+    fn to_sorted_vec(self) -> Vec<T> { self.into_sorted_vec() }
+
     /// Consumes the `PriorityQueue` and returns the underlying vector
     /// in arbitrary order.
     ///

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

@@ -19,7 +19,6 @@ use core::cmp;
 use core::default::Default;
 use core::fmt;
 use core::iter;
-use core::slice;
 use std::hash::{Writer, Hash};
 
 use {Deque, Mutable, MutableSeq};
@@ -133,6 +132,32 @@ impl<T> RingBuf<T> {
               elts: Vec::from_fn(cmp::max(MINIMUM_CAPACITY, n), |_| None)}
     }
 
+    /// Retrieve an element in the `RingBuf` by index.
+    ///
+    /// Fails if there is no element with the given index.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// #![allow(deprecated)]
+    ///
+    /// use std::collections::RingBuf;
+    ///
+    /// let mut buf = RingBuf::new();
+    /// buf.push(3i);
+    /// buf.push(4);
+    /// buf.push(5);
+    /// assert_eq!(buf.get(1), &4);
+    /// ```
+    #[deprecated = "prefer using indexing, e.g., ringbuf[0]"]
+    pub fn get<'a>(&'a self, i: uint) -> &'a T {
+        let idx = self.raw_index(i);
+        match self.elts[idx] {
+            None => fail!(),
+            Some(ref v) => v
+        }
+    }
+
     /// Retrieves an element in the `RingBuf` by index.
     ///
     /// Fails if there is no element with the given index.
@@ -225,6 +250,12 @@ impl<T> RingBuf<T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
     }
 
+    /// Deprecated: use `iter_mut`
+    #[deprecated = "use iter_mut"]
+    pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
+        self.iter_mut()
+    }
+
     /// Returns a front-to-back iterator which returns mutable references.
     ///
     /// # Example
@@ -254,20 +285,16 @@ impl<T> RingBuf<T> {
             //    0 to end_index
             let (temp, remaining1) = self.elts.split_at_mut(start_index);
             let (remaining2, _) = temp.split_at_mut(end_index);
-            MutItems {
-                remaining1: remaining1.iter_mut(),
-                remaining2: remaining2.iter_mut(),
-                nelts: self.nelts,
-            }
+            MutItems { remaining1: remaining1,
+                                 remaining2: remaining2,
+                                 nelts: self.nelts }
         } else {
             // Items to iterate goes from start_index to end_index:
             let (empty, elts) = self.elts.split_at_mut(0);
             let remaining1 = elts[mut start_index..end_index];
-            MutItems {
-                remaining1: remaining1.iter_mut(),
-                remaining2: empty.iter_mut(),
-                nelts: self.nelts,
-            }
+            MutItems { remaining1: remaining1,
+                                 remaining2: empty,
+                                 nelts: self.nelts }
         }
     }
 }
@@ -329,26 +356,26 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
 
 /// `RingBuf` mutable iterator.
 pub struct MutItems<'a, T:'a> {
-    remaining1: slice::MutItems<'a, Option<T>>,
-    remaining2: slice::MutItems<'a, Option<T>>,
+    remaining1: &'a mut [Option<T>],
+    remaining2: &'a mut [Option<T>],
     nelts: uint,
 }
 
 impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
     #[inline]
+    #[allow(deprecated)] // mut_shift_ref
     fn next(&mut self) -> Option<&'a mut T> {
         if self.nelts == 0 {
             return None;
         }
+        let r = if self.remaining1.len() > 0 {
+            &mut self.remaining1
+        } else {
+            assert!(self.remaining2.len() > 0);
+            &mut self.remaining2
+        };
         self.nelts -= 1;
-        match self.remaining1.next() {
-            Some(ptr) => return Some(ptr.as_mut().unwrap()),
-            None => {}
-        }
-        match self.remaining2.next() {
-            Some(ptr) => return Some(ptr.as_mut().unwrap()),
-            None => unreachable!(),
-        }
+        Some(r.mut_shift_ref().unwrap().get_mut_ref())
     }
 
     #[inline]
@@ -359,19 +386,19 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
 
 impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> {
     #[inline]
+    #[allow(deprecated)] // mut_shift_ref
     fn next_back(&mut self) -> Option<&'a mut T> {
         if self.nelts == 0 {
             return None;
         }
+        let r = if self.remaining2.len() > 0 {
+            &mut self.remaining2
+        } else {
+            assert!(self.remaining1.len() > 0);
+            &mut self.remaining1
+        };
         self.nelts -= 1;
-        match self.remaining2.next_back() {
-            Some(ptr) => return Some(ptr.as_mut().unwrap()),
-            None => {}
-        }
-        match self.remaining1.next_back() {
-            Some(ptr) => return Some(ptr.as_mut().unwrap()),
-            None => unreachable!(),
-        }
+        Some(r.mut_pop_ref().unwrap().get_mut_ref())
     }
 }
 
@@ -457,12 +484,9 @@ impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> {
 
 impl<A> Index<uint, A> for RingBuf<A> {
     #[inline]
+    #[allow(deprecated)]
     fn index<'a>(&'a self, i: &uint) -> &'a A {
-        let idx = self.raw_index(*i);
-        match self.elts[idx] {
-            None => fail!(),
-            Some(ref v) => v,
-        }
+        self.get(*i)
     }
 }
 
@@ -552,14 +576,14 @@ mod tests {
         assert_eq!(d.len(), 3u);
         d.push_front(1);
         assert_eq!(d.len(), 4u);
-        debug!("{}", d[0]);
-        debug!("{}", d[1]);
-        debug!("{}", d[2]);
-        debug!("{}", d[3]);
-        assert_eq!(d[0], 1);
-        assert_eq!(d[1], 2);
-        assert_eq!(d[2], 3);
-        assert_eq!(d[3], 4);
+        debug!("{}", d.get(0));
+        debug!("{}", d.get(1));
+        debug!("{}", d.get(2));
+        debug!("{}", d.get(3));
+        assert_eq!(*d.get(0), 1);
+        assert_eq!(*d.get(1), 2);
+        assert_eq!(*d.get(2), 3);
+        assert_eq!(*d.get(3), 4);
     }
 
     #[cfg(test)]