Rollup of 10 pull requests

src/doc/book/ffi.md

@@ -309,7 +309,7 @@ However it is often desired that the callback is targeted to a special
 Rust object. This could be the object that represents the wrapper for the
 respective C object.
 
-This can be achieved by passing an raw pointer to the object down to the
+This can be achieved by passing a raw pointer to the object down to the
 C library. The C library can then include the pointer to the Rust object in
 the notification. This will allow the callback to unsafely access the
 referenced Rust object.

src/doc/nomicon/dropck.md

@@ -125,7 +125,7 @@ is that some Drop implementations will not access borrowed data even
 though their type gives them the capability for such access.
 
 For example, this variant of the above `Inspector` example will never
-accessed borrowed data:
+access borrowed data:
 
 ```rust,ignore
 struct Inspector<'a>(&'a u8, &'static str);

src/doc/nomicon/unbounded-lifetimes.md

@@ -11,7 +11,7 @@ lifetime can be regarded as `'static`.
 
 Almost no reference is `'static`, so this is probably wrong. `transmute` and
 `transmute_copy` are the two other primary offenders. One should endeavor to
-bound an unbounded lifetime as quick as possible, especially across function
+bound an unbounded lifetime as quickly as possible, especially across function
 boundaries.
 
 Given a function, any output lifetimes that don't derive from inputs are

src/libcollections/btree/map.rs

@@ -1990,11 +1990,11 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
     /// use std::collections::BTreeMap;
     ///
     /// let mut map: BTreeMap<&str, String> = BTreeMap::new();
-    /// let s = "hoho".to_owned();
+    /// let s = "hoho".to_string();
     ///
     /// map.entry("poneyland").or_insert_with(|| s);
     ///
-    /// assert_eq!(map["poneyland"], "hoho".to_owned());
+    /// assert_eq!(map["poneyland"], "hoho".to_string());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {

src/libcollections/slice.rs

@@ -423,7 +423,7 @@ impl<T> [T] {
         core_slice::SliceExt::get_unchecked_mut(self, index)
     }
 
-    /// Returns an raw pointer to the slice's buffer.
+    /// Returns a raw pointer to the slice's buffer.
     ///
     /// The caller must ensure that the slice outlives the pointer this
     /// function returns, or else it will end up pointing to garbage.

src/libcompiler_builtins/build.rs

@@ -236,10 +236,6 @@ fn main() {
                          "atomic_thread_fence.c"]);
     }
 
-    if !target.contains("redox") && !target.contains("windows") {
-        sources.extend(&["emutls.c"]);
-    }
-
     if target.contains("msvc") {
         if target.contains("x86_64") {
             sources.extend(&["x86_64/floatdidf.c", "x86_64/floatdisf.c", "x86_64/floatdixf.c"]);

src/libcore/any.rs

@@ -101,7 +101,7 @@ pub trait Any: 'static {
     ///
     /// fn main() {
     ///     assert_eq!(is_string(&0), false);
-    ///     assert_eq!(is_string(&"cookie monster".to_owned()), true);
+    ///     assert_eq!(is_string(&"cookie monster".to_string()), true);
     /// }
     /// ```
     #[unstable(feature = "get_type_id",
@@ -154,7 +154,7 @@ impl Any {
     ///
     /// fn main() {
     ///     is_string(&0);
-    ///     is_string(&"cookie monster".to_owned());
+    ///     is_string(&"cookie monster".to_string());
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -188,7 +188,7 @@ impl Any {
     ///
     /// fn main() {
     ///     print_if_string(&0);
-    ///     print_if_string(&"cookie monster".to_owned());
+    ///     print_if_string(&"cookie monster".to_string());
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -219,7 +219,7 @@ impl Any {
     ///
     /// fn main() {
     ///     let mut x = 10u32;
-    ///     let mut s = "starlord".to_owned();
+    ///     let mut s = "starlord".to_string();
     ///
     ///     modify_if_u32(&mut x);
     ///     modify_if_u32(&mut s);
@@ -259,7 +259,7 @@ impl Any+Send {
     ///
     /// fn main() {
     ///     is_string(&0);
-    ///     is_string(&"cookie monster".to_owned());
+    ///     is_string(&"cookie monster".to_string());
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -285,7 +285,7 @@ impl Any+Send {
     ///
     /// fn main() {
     ///     print_if_string(&0);
-    ///     print_if_string(&"cookie monster".to_owned());
+    ///     print_if_string(&"cookie monster".to_string());
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -309,7 +309,7 @@ impl Any+Send {
     ///
     /// fn main() {
     ///     let mut x = 10u32;
-    ///     let mut s = "starlord".to_owned();
+    ///     let mut s = "starlord".to_string();
     ///
     ///     modify_if_u32(&mut x);
     ///     modify_if_u32(&mut s);
@@ -359,7 +359,7 @@ impl TypeId {
     ///
     /// fn main() {
     ///     assert_eq!(is_string(&0), false);
-    ///     assert_eq!(is_string(&"cookie monster".to_owned()), true);
+    ///     assert_eq!(is_string(&"cookie monster".to_string()), true);
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]

src/libcore/iter/iterator.rs

@@ -1612,7 +1612,7 @@ pub trait Iterator {
 
     /// Returns the maximum element of an iterator.
     ///
-    /// If the two elements are equally maximum, the latest element is
+    /// If several elements are equally maximum, the last element is
     /// returned.
     ///
     /// # Examples
@@ -1638,7 +1638,7 @@ pub trait Iterator {
 
     /// Returns the minimum element of an iterator.
     ///
-    /// If the two elements are equally minimum, the first element is
+    /// If several elements are equally minimum, the first element is
     /// returned.
     ///
     /// # Examples
@@ -1665,8 +1665,8 @@ pub trait Iterator {
     /// Returns the element that gives the maximum value from the
     /// specified function.
     ///
-    /// Returns the rightmost element if the comparison determines two elements
-    /// to be equally maximum.
+    /// If several elements are equally maximum, the last element is
+    /// returned.
     ///
     /// # Examples
     ///
@@ -1690,8 +1690,8 @@ pub trait Iterator {
     /// Returns the element that gives the maximum value with respect to the
     /// specified comparison function.
     ///
-    /// Returns the rightmost element if the comparison determines two elements
-    /// to be equally maximum.
+    /// If several elements are equally maximum, the last element is
+    /// returned.
     ///
     /// # Examples
     ///
@@ -1715,8 +1715,8 @@ pub trait Iterator {
     /// Returns the element that gives the minimum value from the
     /// specified function.
     ///
-    /// Returns the latest element if the comparison determines two elements
-    /// to be equally minimum.
+    /// If several elements are equally minimum, the first element is
+    /// returned.
     ///
     /// # Examples
     ///
@@ -1739,8 +1739,8 @@ pub trait Iterator {
     /// Returns the element that gives the minimum value with respect to the
     /// specified comparison function.
     ///
-    /// Returns the latest element if the comparison determines two elements
-    /// to be equally minimum.
+    /// If several elements are equally minimum, the first element is
+    /// returned.
     ///
     /// # Examples
     ///

src/libcore/iter/traits.rs

@@ -260,7 +260,10 @@ impl<I: Iterator> IntoIterator for I {
 ///
 /// Iterators produce a series of values, and collections can also be thought
 /// of as a series of values. The `Extend` trait bridges this gap, allowing you
-/// to extend a collection by including the contents of that iterator.
+/// to extend a collection by including the contents of that iterator. When
+/// extending a collection with an already existing key, that entry is updated
+/// or, in the case of collections that permit multiple entries with equal
+/// keys, that entry is inserted.
 ///
 /// # Examples
 ///

src/libstd/collections/hash/map.rs

@@ -1779,11 +1779,11 @@ impl<'a, K, V> Entry<'a, K, V> {
     /// use std::collections::HashMap;
     ///
     /// let mut map: HashMap<&str, String> = HashMap::new();
-    /// let s = "hoho".to_owned();
+    /// let s = "hoho".to_string();
     ///
     /// map.entry("poneyland").or_insert_with(|| s);
     ///
-    /// assert_eq!(map["poneyland"], "hoho".to_owned());
+    /// assert_eq!(map["poneyland"], "hoho".to_string());
     /// ```
     pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
         match self {

src/libstd/io/error.rs

@@ -388,12 +388,12 @@ impl Error {
     /// impl MyError {
     ///     fn new() -> MyError {
     ///         MyError {
-    ///             v: "oh no!".to_owned()
+    ///             v: "oh no!".to_string()
     ///         }
     ///     }
     ///
     ///     fn change_message(&mut self, new_message: &str) {
-    ///         self.v = new_message.to_owned();
+    ///         self.v = new_message.to_string();
     ///     }
     /// }
     ///

src/libstd/net/udp.rs

@@ -883,11 +883,23 @@ mod tests {
 
     #[test]
     fn set_nonblocking() {
-        let addr = next_test_ip4();
+        each_ip(&mut |addr, _| {
+            let socket = t!(UdpSocket::bind(&addr));
 
-        let stream = t!(UdpSocket::bind(&addr));
+            t!(socket.set_nonblocking(true));
+            t!(socket.set_nonblocking(false));
+
+            t!(socket.connect(addr));
 
-        t!(stream.set_nonblocking(true));
-        t!(stream.set_nonblocking(false));
+            t!(socket.set_nonblocking(false));
+            t!(socket.set_nonblocking(true));
+
+            let mut buf = [0];
+            match socket.recv(&mut buf) {
+                Ok(_) => panic!("expected error"),
+                Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
+                Err(e) => panic!("unexpected error {}", e),
+            }
+        })
     }
 }