---

yaml
---
r: 166453
b: refs/heads/snap-stage3
c: d10642e
h: refs/heads/master
i:
  166451: 67979fd
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 18842f89f084c52588fe7cffe07f87bf6e90796a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: adabf4e63d6b1d33b045aa5078b12dec3693c574
+refs/heads/snap-stage3: d10642ef0f8976b9fb08500acdff84e3990815fa
 refs/heads/try: f5d619caf9f32458680fae55526b99582ca682dd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/doc/complement-bugreport.md

@@ -34,7 +34,7 @@ miss out on valid bug reports.
 It generally helps our diagnosis to include your specific OS (for example: Mac OS X 10.8.3,
 Windows 7, Ubuntu 12.04) and your hardware architecture (for example: i686, x86_64).
 It's also helpful to provide the exact version and host by copying the output of
-re-running the erroneous rustc command with the `--version=verbose` flag, which will
+re-running the erroneous rustc command with the `--version --verbose` flags, which will
 produce something like this:
 
 ```text

branches/snap-stage3/src/etc/rustup.sh

@@ -441,7 +441,7 @@ install_package() {
     install_script="$2"
 
     msg "Extracting ${tarball_name}"
-    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xvf "${tarball_name}")
+    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xzf "${tarball_name}")
     if [ $? -ne 0 ]; then
         rm -Rf "${CFG_TMP_DIR}"
         err "failed to unpack installer"

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

@@ -1295,9 +1295,6 @@ impl<A: PartialEq> PartialEq for RingBuf<A> {
         self.len() == other.len() &&
             self.iter().zip(other.iter()).all(|(a, b)| a.eq(b))
     }
-    fn ne(&self, other: &RingBuf<A>) -> bool {
-        !self.eq(other)
-    }
 }
 
 impl<A: Eq> Eq for RingBuf<A> {}

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

@@ -60,7 +60,6 @@ use vec::Vec;
 /// months.clear();
 /// assert!(months.is_empty());
 /// ```
-#[deriving(PartialEq, Eq)]
 pub struct VecMap<V> {
     v: Vec<Option<V>>,
 }
@@ -492,6 +491,14 @@ impl<V:Clone> VecMap<V> {
     }
 }
 
+impl<V: PartialEq> PartialEq for VecMap<V> {
+    fn eq(&self, other: &VecMap<V>) -> bool {
+        iter::order::eq(self.iter(), other.iter())
+    }
+}
+
+impl<V: Eq> Eq for VecMap<V> {}
+
 impl<V: PartialOrd> PartialOrd for VecMap<V> {
     #[inline]
     fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering> {
@@ -955,6 +962,10 @@ mod test_map {
         assert!(a != b);
         assert!(b.insert(5, 19).is_none());
         assert!(a == b);
+
+        a = VecMap::new();
+        b = VecMap::with_capacity(1);
+        assert!(a == b);
     }
 
     #[test]

branches/snap-stage3/src/libstd/ascii.rs

@@ -39,7 +39,7 @@ impl Ascii {
         self.chr
     }
 
-    /// Deprecated: use `as_byte` isntead.
+    /// Deprecated: use `as_byte` instead.
     #[deprecated = "use as_byte"]
     pub fn to_byte(self) -> u8 {
         self.as_byte()
@@ -52,7 +52,7 @@ impl Ascii {
         self.chr as char
     }
 
-    /// Deprecated: use `as_char` isntead.
+    /// Deprecated: use `as_char` instead.
     #[deprecated = "use as_char"]
     pub fn to_char(self) -> char {
         self.as_char()

branches/snap-stage3/src/libstd/comm/mod.rs

@@ -547,7 +547,7 @@ impl<T: Send> Sender<T> {
     /// so it is possible for a send to succeed (the other end is alive), but
     /// then the other end could immediately disconnect.
     ///
-    /// The purpose of this functionality is to propagate panicks among tasks.
+    /// The purpose of this functionality is to propagate panics among tasks.
     /// If a panic is not desired, then consider using the `send_opt` method
     #[experimental = "this function is being considered candidate for removal \
                       to adhere to the general guidelines of rust"]
@@ -790,7 +790,7 @@ impl<T: Send> Receiver<T> {
     ///
     /// Similar to channels, this method will trigger a task panic if the
     /// other end of the channel has hung up (been deallocated). The purpose of
-    /// this is to propagate panicks among tasks.
+    /// this is to propagate panics among tasks.
     ///
     /// If a panic is not desired, then there are two options:
     ///

branches/snap-stage3/src/libstd/io/net/ip.rs

@@ -383,8 +383,8 @@ impl FromStr for SocketAddr {
 ///    expected by its `FromStr` implementation or a string like `<host_name>:<port>` pair
 ///    where `<port>` is a `u16` value.
 ///
-///    For the former, `to_socker_addr_all` returns a vector with a single element corresponding
-///    to that socker address.
+///    For the former, `to_socket_addr_all` returns a vector with a single element corresponding
+///    to that socket address.
 ///
 ///    For the latter, it tries to resolve the host name and returns a vector of all IP addresses
 ///    for the host name, each joined with the port.
@@ -443,7 +443,7 @@ pub trait ToSocketAddr {
 
     /// Converts this object to all available socket address values.
     ///
-    /// Some values like host name string naturally corrrespond to multiple IP addresses.
+    /// Some values like host name string naturally correspond to multiple IP addresses.
     /// This method tries to return all available addresses corresponding to this object.
     ///
     /// By default this method delegates to `to_socket_addr` method, creating a singleton

branches/snap-stage3/src/libstd/io/net/tcp.rs

@@ -319,7 +319,7 @@ impl TcpListener {
     /// to this listener. The port allocated can be queried via the
     /// `socket_name` function.
     ///
-    /// The address type can be any implementor of `ToSocketAddr` trait. See its
+    /// The address type can be any implementer of `ToSocketAddr` trait. See its
     /// documentation for concrete examples.
     pub fn bind<A: ToSocketAddr>(addr: A) -> IoResult<TcpListener> {
         super::with_addresses(addr, |addr| {

branches/snap-stage3/src/libstd/io/net/udp.rs

@@ -82,7 +82,7 @@ impl UdpSocket {
     /// Sends data on the socket to the given address. Returns nothing on
     /// success.
     ///
-    /// Address type can be any implementor of `ToSocketAddr` trait. See its
+    /// Address type can be any implementer of `ToSocketAddr` trait. See its
     /// documentation for concrete examples.
     pub fn send_to<A: ToSocketAddr>(&mut self, buf: &[u8], addr: A) -> IoResult<()> {
         super::with_addresses(addr, |addr| self.inner.send_to(buf, addr))

branches/snap-stage3/src/libstd/sync/rwlock.rs

@@ -60,7 +60,7 @@ pub struct RWLock<T> {
     data: UnsafeCell<T>,
 }
 
-/// Structure representing a staticaly allocated RWLock.
+/// Structure representing a statically allocated RWLock.
 ///
 /// This structure is intended to be used inside of a `static` and will provide
 /// automatic global access as well as lazy initialization. The internal

branches/snap-stage3/src/libstd/thread_local/scoped.rs

@@ -17,7 +17,7 @@
 //!
 //! There are no restrictions on what types can be placed into a scoped
 //! variable, but all scoped variables are initialized to the equivalent of
-//! null. Scoped thread local stor is useful when a value is present for a known
+//! null. Scoped thread local storage is useful when a value is present for a known
 //! period of time and it is not required to relinquish ownership of the
 //! contents.
 //!