Auto merge of #28900 - cristicbz:typos, r=alexcrichton

I found these automatically, but fixed them manually to ensure the semantics are correct. I know things like these are hardly important, since they only marginally improve clarity. But at least for me typos and simple grammatical errors trigger an---unjustified---sense of unprofessionalism, despite the fact that I make them all the time and I understand that they're the sort of thing that is bound to slip through review.  

Anyway, to find most of these I used:

  * `ag '.*//.*(\b[A-Za-z]{2,}\b) \1\b'` for repeated words

  * `ag '\b(the|this|those|these|a|it) (a|the|this|those|these|it)\b'` to find constructs like 'the this' etc. many false positives, but not too hard to scroll through them to actually find the mistakes.

  * `cat ../../typos.txt | paste -d'|' - - - - - - - - - - - - - - - - - - - - - - | tr '\n' '\0' | xargs -0 -P4 -n1 ag`. Hacky way to find misspellings, but it works ok. I got `typos.txt` from [Wikipedia](https://en.wikipedia.org/wiki/Wikipedia:Lists_of_common_misspellings/For_machines)

* `ag '.*//.* a ([ae][a-z]|(o[^n])|(i[a-rt-z]))'` to find places where 'a' was followed by a vowel (requiring 'an' instead).

I also used a handful more one off regexes that are too boring to reproduce here.

Author: bors

src/doc/grammar.md

@@ -773,7 +773,7 @@ bound := path | lifetime
 
 ## Type kinds
 
-**FIXME:** this this probably not relevant to the grammar...
+**FIXME:** this is probably not relevant to the grammar...
 
 # Memory and concurrency models
 

src/doc/trpl/concurrency.md

@@ -195,7 +195,7 @@ our value if it's immutable, but we want to be able to mutate it, so we need
 something else to persuade the borrow checker we know what we're doing.
 
 It looks like we need some type that allows us to safely mutate a shared value,
-for example a type that that can ensure only one thread at a time is able to
+for example a type that can ensure only one thread at a time is able to
 mutate the value inside it at any one time.
 
 For that, we can use the `Mutex<T>` type!

src/doc/trpl/iterators.md

@@ -302,7 +302,7 @@ This will print
 
 `filter()` is an adapter that takes a closure as an argument. This closure
 returns `true` or `false`. The new iterator `filter()` produces
-only the elements that that closure returns `true` for:
+only the elements that the closure returns `true` for:
 
 ```rust
 for i in (1..100).filter(|&x| x % 2 == 0) {

src/etc/test-float-parse/runtests.py

@@ -71,7 +71,7 @@
 
 Incomplete records are an error. Not-a-Number bit patterns are invalid too.
 
-The tests run serially but the validaition for a a single test is parallelized
+The tests run serially but the validation for a single test is parallelized
 with ``multiprocessing``. Each test is launched as a subprocess.
 One thread supervises it: Accepts and enqueues records to validate, observe
 stderr, and waits for the process to exit. A set of worker processes perform

src/libcollections/btree/map.rs

@@ -593,7 +593,7 @@ mod stack {
         top: node::Handle<*mut Node<K, V>, Type, NodeType>,
     }
 
-    /// A `PartialSearchStack` that doesn't hold a a reference to the next node, and is just
+    /// A `PartialSearchStack` that doesn't hold a reference to the next node, and is just
     /// just waiting for a `Handle` to that next node to be pushed. See `PartialSearchStack::with`
     /// for more details.
     pub struct Pusher<'id, 'a, K:'a, V:'a> {

src/libcollectionstest/str.rs

@@ -86,7 +86,7 @@ fn test_find_str() {
     assert_eq!(data[43..86].find("iệt"), Some(77 - 43));
     assert_eq!(data[43..86].find("Nam"), Some(83 - 43));
 
-    // find every substring -- assert that it finds it, or an earlier occurence.
+    // find every substring -- assert that it finds it, or an earlier occurrence.
     let string = "Việt Namacbaabcaabaaba";
     for (i, ci) in string.char_indices() {
         let ip = i + ci.len_utf8();

src/libcore/cell.rs

@@ -598,7 +598,7 @@ impl<'b, T: ?Sized> Ref<'b, T> {
         }
     }
 
-    /// Make a new `Ref` for a optional component of the borrowed data, e.g. an
+    /// Make a new `Ref` for an optional component of the borrowed data, e.g. an
     /// enum variant.
     ///
     /// The `RefCell` is already immutably borrowed, so this cannot fail.
@@ -668,7 +668,7 @@ impl<'b, T: ?Sized> RefMut<'b, T> {
         }
     }
 
-    /// Make a new `RefMut` for a optional component of the borrowed data, e.g.
+    /// Make a new `RefMut` for an optional component of the borrowed data, e.g.
     /// an enum variant.
     ///
     /// The `RefCell` is already mutably borrowed, so this cannot fail.

src/libcore/intrinsics.rs

@@ -373,20 +373,20 @@ extern "rust-intrinsic" {
     /// a size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`
     ///
-    /// The volatile parameter parameter is set to `true`, so it will not be optimized out.
+    /// The volatile parameter is set to `true`, so it will not be optimized out.
     pub fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T,
                                                   count: usize);
     /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
     /// a size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`
     ///
-    /// The volatile parameter parameter is set to `true`, so it will not be optimized out.
+    /// The volatile parameter is set to `true`, so it will not be optimized out.
     pub fn volatile_copy_memory<T>(dst: *mut T, src: *const T, count: usize);
     /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
     /// size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`.
     ///
-    /// The volatile parameter parameter is set to `true`, so it will not be optimized out.
+    /// The volatile parameter is set to `true`, so it will not be optimized out.
     pub fn volatile_set_memory<T>(dst: *mut T, val: u8, count: usize);
 
     /// Perform a volatile load from the `src` pointer.

src/libcore/marker.rs

@@ -381,7 +381,7 @@ mod impls {
 /// ```
 ///
 /// Without the declaration `T:Reflect`, `foo` would not type check
-/// (note: as a matter of style, it would be preferable to to write
+/// (note: as a matter of style, it would be preferable to write
 /// `T:Any`, because `T:Any` implies `T:Reflect` and `T:'static`, but
 /// we use `Reflect` here to show how it works). The `Reflect` bound
 /// thus serves to alert `foo`'s caller to the fact that `foo` may

src/libcore/num/bignum.rs

@@ -110,7 +110,7 @@ macro_rules! define_bignum {
     ($name:ident: type=$ty:ty, n=$n:expr) => (
         /// Stack-allocated arbitrary-precision (up to certain limit) integer.
         ///
-        /// This is backed by an fixed-size array of given type ("digit").
+        /// This is backed by a fixed-size array of given type ("digit").
         /// While the array is not very large (normally some hundred bytes),
         /// copying it recklessly may result in the performance hit.
         /// Thus this is intentionally not `Copy`.