Auto merge of rust-lang#39030 - GuillaumeGomez:rollup, r=GuillaumeGomez

Rollup of 10 pull requests

- Successful merges: rust-lang#38362, rust-lang#38636, rust-lang#38877, rust-lang#38946, rust-lang#38965, rust-lang#38986, rust-lang#38994, rust-lang#38995, rust-lang#39024, rust-lang#39027
- Failed merges:

Author: bors

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 {