---

yaml
---
r: 216751
b: refs/heads/stable
c: 468cb05
h: refs/heads/master
i:
  216749: 2976a26
  216747: 6d90024
  216743: 23eec89
  216735: 833c48f
v: v3

Author: carols10cents

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 4b4cb86248ef3540fd531a25d53c13069887a018
+refs/heads/stable: 468cb052b8e104f3c79dbb522b57a504f52ba1c1
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/configure

@@ -844,7 +844,7 @@ then
     CFG_OSX_GCC_VERSION=$("$CFG_GCC" --version 2>&1 | grep "Apple LLVM version")
     if [ $? -eq 0 ]
     then
-        step_msg "on OS X 10.9, forcing use of clang"
+        step_msg "on OS X >=10.9, forcing use of clang"
         CFG_ENABLE_CLANG=1
     else
         if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then

branches/stable/src/doc/trpl/guessing-game.md

@@ -358,10 +358,11 @@ rand="0.3.0"
 The `[dependencies]` section of `Cargo.toml` is like the `[package]` section:
 everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
-crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
-Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use the latest version we could use `*` or we could use a range 
-of versions. [Cargo’s documentation][cargodoc] contains more details.
+crates you have, and what versions you require. In this case, we’ve used `*`,
+which means that we’ll use the latest version of `rand`. Cargo understands
+[Semantic Versioning][semver], which is a standard for writing version
+numbers. If we wanted a specific version or range of versions, we could be
+more specific here. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org
 [cargodoc]: http://doc.crates.io/crates-io.html
@@ -409,7 +410,7 @@ $ cargo build
    Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
 ```
 
-So, we told Cargo we wanted any `0.3.x` version of `rand`, and so it fetched the latest
+So, we told Cargo we wanted any version of `rand`, and so it fetched the latest
 version at the time this was written, `v0.3.8`. But what happens when next
 week, version `v0.3.9` comes out, with an important bugfix? While getting
 bugfixes is important, what if `0.3.9` contains a regression that breaks our

branches/stable/src/doc/trpl/lifetimes.md

@@ -116,7 +116,7 @@ fn main() {
 }
 ```
 
-[structs]: structs.html
+[struct]: structs.html
 
 As you can see, `struct`s can also have lifetimes. In a similar way to functions,
 

branches/stable/src/doc/trpl/mutability.md

@@ -85,7 +85,7 @@ safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * one or more references (`&T`) to a resource.
+> * 0 to N references (`&T`) to a resource.
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html

branches/stable/src/doc/trpl/ownership.md

@@ -3,7 +3,7 @@
 This guide is one of three presenting Rust’s ownership system. This is one of
 Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
-memory safety. There are a few distinct concepts, each with its own
+memory safety. The there are a few distinct concepts, each with its own
 chapter:
 
 * ownership, which you’re reading now.
@@ -59,7 +59,6 @@ deterministically, at the end of the scope.
 
 [vect]: ../std/vec/struct.Vec.html
 [heap]: the-stack-and-the-heap.html
-[bindings]: variable-bindings.html
 
 # Move semantics
 
@@ -123,7 +122,7 @@ let v2 = v;
 
 The first line creates some data for the vector on the [stack][sh], `v`. The
 vector’s data, however, is stored on the [heap][sh], and so it contains a
-pointer to that data. When we move `v` to `v2`, it creates a copy of that pointer,
+pointer to that data. When we move `v` to `v2`, it creates a copy of that data,
 for `v2`. Which would mean two pointers to the contents of the vector on the
 heap. That would be a problem: it would violate Rust’s safety guarantees by
 introducing a data race. Therefore, Rust forbids using `v` after we’ve done the

branches/stable/src/doc/trpl/references-and-borrowing.md

@@ -3,7 +3,7 @@
 This guide is one of three presenting Rust’s ownership system. This is one of
 Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
-memory safety. There are a few distinct concepts, each with its own
+memory safety. The there are a few distinct concepts, each with its own
 chapter:
 
 * [ownership][ownership], ownership, the key concept

branches/stable/src/doc/trpl/traits.md

@@ -192,7 +192,7 @@ Here’s the error:
 ```text
 error: type `std::fs::File` does not implement any method in scope named `write`
 
-let result = f.write(b"whatever");
+let result = f.write(b”whatever”);
                ^~~~~~~~~~~~~~~~~~
 ```
 

branches/stable/src/libcollections/vec.rs

@@ -67,7 +67,7 @@ use core::intrinsics::assume;
 use core::iter::{repeat, FromIterator};
 use core::marker::PhantomData;
 use core::mem;
-use core::ops::{Index, IndexMut, Deref};
+use core::ops::{Index, IndexMut, Deref, Add};
 use core::ops;
 use core::ptr;
 use core::ptr::Unique;
@@ -1622,6 +1622,17 @@ impl<T: Ord> Ord for Vec<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
+    type Output = Vec<T>;
+
+    #[inline]
+    fn add(mut self, rhs: &[T]) -> Vec<T> {
+        self.push_all(rhs);
+        self
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {

branches/stable/src/libcore/iter.rs

@@ -137,7 +137,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().last().unwrap(), &5);
+    /// assert!(a.iter().last().unwrap() == &5);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -155,8 +155,8 @@ pub trait Iterator {
     /// ```
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
-    /// assert_eq!(it.nth(2).unwrap(), &3);
-    /// assert_eq!(it.nth(2), None);
+    /// assert!(it.nth(2).unwrap() == &3);
+    /// assert!(it.nth(2) == None);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -545,8 +545,8 @@ pub trait Iterator {
     /// let mut it = 0..10;
     /// // sum the first five values
     /// let partial_sum = it.by_ref().take(5).fold(0, |a, b| a + b);
-    /// assert_eq!(partial_sum, 10);
-    /// assert_eq!(it.next(), Some(5));
+    /// assert!(partial_sum == 10);
+    /// assert!(it.next() == Some(5));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
@@ -608,7 +608,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().fold(0, |acc, &item| acc + item), 15);
+    /// assert!(a.iter().fold(0, |acc, &item| acc + item) == 15);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -773,7 +773,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().max().unwrap(), &5);
+    /// assert!(a.iter().max().unwrap() == &5);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -796,7 +796,7 @@ pub trait Iterator {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().min().unwrap(), &1);
+    /// assert!(a.iter().min().unwrap() == &1);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -834,13 +834,13 @@ pub trait Iterator {
     /// assert_eq!(a.iter().min_max(), NoElements);
     ///
     /// let a = [1];
-    /// assert_eq!(a.iter().min_max(), OneElement(&1));
+    /// assert!(a.iter().min_max() == OneElement(&1));
     ///
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().min_max(), MinMax(&1, &5));
+    /// assert!(a.iter().min_max() == MinMax(&1, &5));
     ///
     /// let a = [1, 1, 1, 1];
-    /// assert_eq!(a.iter().min_max(), MinMax(&1, &1));
+    /// assert!(a.iter().min_max() == MinMax(&1, &1));
     /// ```
     #[unstable(feature = "core", reason = "return type may change")]
     fn min_max(mut self) -> MinMaxResult<Self::Item> where Self: Sized, Self::Item: Ord
@@ -1058,7 +1058,7 @@ pub trait Iterator {
     ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().cloned();
-    /// assert_eq!(it.sum::<i32>(), 15);
+    /// assert!(it.sum::<i32>() == 15);
     /// ```
     #[unstable(feature="core")]
     fn sum<S=<Self as Iterator>::Item>(self) -> S where
@@ -1078,9 +1078,9 @@ pub trait Iterator {
     /// fn factorial(n: u32) -> u32 {
     ///     (1..).take_while(|&i| i <= n).product()
     /// }
-    /// assert_eq!(factorial(0), 1);
-    /// assert_eq!(factorial(1), 1);
-    /// assert_eq!(factorial(5), 120);
+    /// assert!(factorial(0) == 1);
+    /// assert!(factorial(1) == 1);
+    /// assert!(factorial(5) == 120);
     /// ```
     #[unstable(feature="core")]
     fn product<P=<Self as Iterator>::Item>(self) -> P where

branches/stable/src/liblibc/lib.rs

@@ -3624,30 +3624,6 @@ pub mod consts {
             pub const IPV6_DROP_MEMBERSHIP: c_int = 21;
 
             pub const TCP_NODELAY: c_int = 1;
-            pub const TCP_MAXSEG: c_int = 2;
-            pub const TCP_CORK: c_int = 3;
-            pub const TCP_KEEPIDLE: c_int = 4;
-            pub const TCP_KEEPINTVL: c_int = 5;
-            pub const TCP_KEEPCNT: c_int = 6;
-            pub const TCP_SYNCNT: c_int = 7;
-            pub const TCP_LINGER2: c_int = 8;
-            pub const TCP_DEFER_ACCEPT: c_int = 9;
-            pub const TCP_WINDOW_CLAMP: c_int = 10;
-            pub const TCP_INFO: c_int = 11;
-            pub const TCP_QUICKACK: c_int = 12;
-            pub const TCP_CONGESTION: c_int = 13;
-            pub const TCP_MD5SIG: c_int = 14;
-            pub const TCP_COOKIE_TRANSACTIONS: c_int = 15;
-            pub const TCP_THIN_LINEAR_TIMEOUTS: c_int = 16;
-            pub const TCP_THIN_DUPACK: c_int = 17;
-            pub const TCP_USER_TIMEOUT: c_int = 18;
-            pub const TCP_REPAIR: c_int = 19;
-            pub const TCP_REPAIR_QUEUE: c_int = 20;
-            pub const TCP_QUEUE_SEQ: c_int = 21;
-            pub const TCP_REPAIR_OPTIONS: c_int = 22;
-            pub const TCP_FASTOPEN: c_int = 23;
-            pub const TCP_TIMESTAMP: c_int = 24;
-
             pub const SOL_SOCKET: c_int = 65535;
 
             pub const SO_DEBUG: c_int = 0x0001;

branches/stable/src/librustc/middle/traits/error_reporting.rs

@@ -56,12 +56,7 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
 {
     let predicate =
         infcx.resolve_type_vars_if_possible(&obligation.predicate);
-    // The ty_err created by normalize_to_error can end up being unified
-    // into all obligations: for example, if our obligation is something
-    // like `$X = <() as Foo<$X>>::Out` and () does not implement Foo<_>,
-    // then $X will be unified with ty_err, but the error still needs to be
-    // reported.
-    if !infcx.tcx.sess.has_errors() || !predicate.references_error() {
+    if !predicate.references_error() {
         span_err!(infcx.tcx.sess, obligation.cause.span, E0271,
                 "type mismatch resolving `{}`: {}",
                 predicate.user_string(infcx.tcx),
@@ -188,8 +183,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                             let trait_predicate =
                                 infcx.resolve_type_vars_if_possible(trait_predicate);
 
-                            if !infcx.tcx.sess.has_errors() ||
-                               !trait_predicate.references_error() {
+                            if !trait_predicate.references_error() {
                                 let trait_ref = trait_predicate.to_poly_trait_ref();
                                 span_err!(infcx.tcx.sess, obligation.cause.span, E0277,
                                         "the trait `{}` is not implemented for the type `{}`",

branches/stable/src/librustc/middle/traits/project.rs

@@ -408,10 +408,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
 }
 
 /// in various error cases, we just set ty_err and return an obligation
-/// that, when fulfilled, will lead to an error.
-///
-/// FIXME: the ty_err created here can enter the obligation we create,
-/// leading to error messages involving ty_err.
+/// that, when fulfilled, will lead to an error
 fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
                                projection_ty: ty::ProjectionTy<'tcx>,
                                cause: ObligationCause<'tcx>,

branches/stable/src/librustc_typeck/diagnostics.rs

@@ -12,28 +12,6 @@
 
 register_long_diagnostics! {
 
-E0046: r##"
-When trying to make some type implement a trait `Foo`, you must, at minimum,
-provide implementations for all of `Foo`'s required methods (meaning the
-methods that do not have default implementations), as well as any required
-trait items like associated types or constants.
-"##,
-
-E0054: r##"
-It is not allowed to cast to a bool. If you are trying to cast a numeric type
-to a bool, you can compare it with zero instead:
-
-```
-let x = 5;
-
-// Ok
-let x_is_nonzero = x != 0;
-
-// Not allowed, won't compile
-let x_is_nonzero = x as bool;
-```
-"##,
-
 E0081: r##"
 Enum discriminants are used to differentiate enum variants stored in memory.
 This error indicates that the same value was used for two or more variants,
@@ -128,9 +106,11 @@ register_diagnostics! {
     E0040, // explicit use of destructor method
     E0044,
     E0045,
+    E0046,
     E0049,
     E0050,
     E0053,
+    E0054,
     E0055,
     E0057,
     E0059,

branches/stable/src/libstd/fs.rs

@@ -23,7 +23,7 @@ use fmt;
 use ffi::OsString;
 use io::{self, Error, ErrorKind, SeekFrom, Seek, Read, Write};
 use path::{Path, PathBuf};
-use sys::fs as fs_imp;
+use sys::fs2 as fs_imp;
 use sys_common::{AsInnerMut, FromInner, AsInner};
 use vec::Vec;
 

branches/stable/src/libstd/net/mod.rs

@@ -15,7 +15,7 @@
 use prelude::v1::*;
 
 use io::{self, Error, ErrorKind};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 
 pub use self::ip::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};
 pub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};

branches/stable/src/libstd/net/tcp.rs

@@ -17,7 +17,7 @@ use io::prelude::*;
 use fmt;
 use io;
 use net::{ToSocketAddrs, SocketAddr, Shutdown};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A structure which represents a TCP stream between a local socket and a

branches/stable/src/libstd/net/udp.rs

@@ -16,7 +16,7 @@ use prelude::v1::*;
 use fmt;
 use io::{self, Error, ErrorKind};
 use net::{ToSocketAddrs, SocketAddr, IpAddr};
-use sys_common::net as net_imp;
+use sys_common::net2 as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A User Datagram Protocol socket.

branches/stable/src/libstd/os/android/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/stable/src/libstd/os/bitrig/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/stable/src/libstd/os/dragonfly/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }

branches/stable/src/libstd/os/freebsd/mod.rs

@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs::MetadataExt;
+    pub use sys::fs2::MetadataExt;
 }