Rollup merge of #110419 - jsoref:spelling-library, r=jyn514

Spelling library

Split per #110392

I can squash once people are happy w/ the changes. It's really uncommon for large sets of changes to be perfectly acceptable w/o at least some changes.

I probably won't have time to respond until tomorrow or the next day

Author: matthiaskrgr

library/alloc/src/collections/vec_deque/spec_from_iter.rs

@@ -12,7 +12,7 @@ where
     default fn spec_from_iter(iterator: I) -> Self {
         // Since converting is O(1) now, just re-use the `Vec` logic for
         // anything where we can't do something extra-special for `VecDeque`,
-        // especially as that could save us some monomorphiziation work
+        // especially as that could save us some monomorphization work
         // if one uses the same iterators (like slice ones) with both.
         crate::vec::Vec::from_iter(iterator).into()
     }

library/alloc/src/str.rs

@@ -404,12 +404,12 @@ impl str {
             // See https://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
             // for the definition of `Final_Sigma`.
             debug_assert!('Σ'.len_utf8() == 2);
-            let is_word_final = case_ignoreable_then_cased(from[..i].chars().rev())
-                && !case_ignoreable_then_cased(from[i + 2..].chars());
+            let is_word_final = case_ignorable_then_cased(from[..i].chars().rev())
+                && !case_ignorable_then_cased(from[i + 2..].chars());
             to.push_str(if is_word_final { "ς" } else { "σ" });
         }
 
-        fn case_ignoreable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
+        fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
             use core::unicode::{Case_Ignorable, Cased};
             match iter.skip_while(|&c| Case_Ignorable(c)).next() {
                 Some(c) => Cased(c),

library/alloc/src/vec/in_place_collect.rs

@@ -201,7 +201,7 @@ where
         //
         // Note: This access to the source wouldn't be allowed by the TrustedRandomIteratorNoCoerce
         // contract (used by SpecInPlaceCollect below). But see the "O(1) collect" section in the
-        // module documenttation why this is ok anyway.
+        // module documentation why this is ok anyway.
         let dst_guard = InPlaceDstBufDrop { ptr: dst_buf, len, cap };
         src.forget_allocation_drop_remaining();
         mem::forget(dst_guard);

library/alloc/tests/slice.rs

@@ -705,7 +705,7 @@ fn test_move_rev_iterator() {
 }
 
 #[test]
-fn test_splitator() {
+fn test_split_iterator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1], &[3], &[5]];
@@ -725,7 +725,7 @@ fn test_splitator() {
 }
 
 #[test]
-fn test_splitator_inclusive() {
+fn test_split_iterator_inclusive() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
@@ -745,7 +745,7 @@ fn test_splitator_inclusive() {
 }
 
 #[test]
-fn test_splitator_inclusive_reverse() {
+fn test_split_iterator_inclusive_reverse() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
@@ -765,7 +765,7 @@ fn test_splitator_inclusive_reverse() {
 }
 
 #[test]
-fn test_splitator_mut_inclusive() {
+fn test_split_iterator_mut_inclusive() {
     let xs = &mut [1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
@@ -785,7 +785,7 @@ fn test_splitator_mut_inclusive() {
 }
 
 #[test]
-fn test_splitator_mut_inclusive_reverse() {
+fn test_split_iterator_mut_inclusive_reverse() {
     let xs = &mut [1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
@@ -805,7 +805,7 @@ fn test_splitator_mut_inclusive_reverse() {
 }
 
 #[test]
-fn test_splitnator() {
+fn test_splitn_iterator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
@@ -821,7 +821,7 @@ fn test_splitnator() {
 }
 
 #[test]
-fn test_splitnator_mut() {
+fn test_splitn_iterator_mut() {
     let xs = &mut [1, 2, 3, 4, 5];
 
     let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
@@ -837,7 +837,7 @@ fn test_splitnator_mut() {
 }
 
 #[test]
-fn test_rsplitator() {
+fn test_rsplit_iterator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[5], &[3], &[1]];
@@ -855,7 +855,7 @@ fn test_rsplitator() {
 }
 
 #[test]
-fn test_rsplitnator() {
+fn test_rsplitn_iterator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
@@ -932,7 +932,7 @@ fn test_split_iterators_size_hint() {
 }
 
 #[test]
-fn test_windowsator() {
+fn test_windows_iterator() {
     let v = &[1, 2, 3, 4];
 
     let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]];
@@ -948,13 +948,13 @@ fn test_windowsator() {
 
 #[test]
 #[should_panic]
-fn test_windowsator_0() {
+fn test_windows_iterator_0() {
     let v = &[1, 2, 3, 4];
     let _it = v.windows(0);
 }
 
 #[test]
-fn test_chunksator() {
+fn test_chunks_iterator() {
     let v = &[1, 2, 3, 4, 5];
 
     assert_eq!(v.chunks(2).len(), 3);
@@ -972,13 +972,13 @@ fn test_chunksator() {
 
 #[test]
 #[should_panic]
-fn test_chunksator_0() {
+fn test_chunks_iterator_0() {
     let v = &[1, 2, 3, 4];
     let _it = v.chunks(0);
 }
 
 #[test]
-fn test_chunks_exactator() {
+fn test_chunks_exact_iterator() {
     let v = &[1, 2, 3, 4, 5];
 
     assert_eq!(v.chunks_exact(2).len(), 2);
@@ -996,13 +996,13 @@ fn test_chunks_exactator() {
 
 #[test]
 #[should_panic]
-fn test_chunks_exactator_0() {
+fn test_chunks_exact_iterator_0() {
     let v = &[1, 2, 3, 4];
     let _it = v.chunks_exact(0);
 }
 
 #[test]
-fn test_rchunksator() {
+fn test_rchunks_iterator() {
     let v = &[1, 2, 3, 4, 5];
 
     assert_eq!(v.rchunks(2).len(), 3);
@@ -1020,13 +1020,13 @@ fn test_rchunksator() {
 
 #[test]
 #[should_panic]
-fn test_rchunksator_0() {
+fn test_rchunks_iterator_0() {
     let v = &[1, 2, 3, 4];
     let _it = v.rchunks(0);
 }
 
 #[test]
-fn test_rchunks_exactator() {
+fn test_rchunks_exact_iterator() {
     let v = &[1, 2, 3, 4, 5];
 
     assert_eq!(v.rchunks_exact(2).len(), 2);
@@ -1044,7 +1044,7 @@ fn test_rchunks_exactator() {
 
 #[test]
 #[should_panic]
-fn test_rchunks_exactator_0() {
+fn test_rchunks_exact_iterator_0() {
     let v = &[1, 2, 3, 4];
     let _it = v.rchunks_exact(0);
 }
@@ -1219,7 +1219,7 @@ fn test_ends_with() {
 }
 
 #[test]
-fn test_mut_splitator() {
+fn test_mut_split_iterator() {
     let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
     assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
     for slice in xs.split_mut(|x| *x == 0) {
@@ -1235,7 +1235,7 @@ fn test_mut_splitator() {
 }
 
 #[test]
-fn test_mut_splitator_rev() {
+fn test_mut_split_iterator_rev() {
     let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
     for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
         slice.reverse();

library/alloc/tests/vec.rs

@@ -2470,7 +2470,7 @@ fn test_vec_dedup_panicking() {
 
 // Regression test for issue #82533
 #[test]
-fn test_extend_from_within_panicing_clone() {
+fn test_extend_from_within_panicking_clone() {
     struct Panic<'dc> {
         drop_count: &'dc AtomicU32,
         aaaaa: bool,

library/core/src/fmt/builders.rs

@@ -109,14 +109,14 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     ///            .field("bar", &self.bar) // We add `bar` field.
     ///            .field("another", &self.another) // We add `another` field.
     ///            // We even add a field which doesn't exist (because why not?).
-    ///            .field("not_existing_field", &1)
+    ///            .field("nonexistent_field", &1)
     ///            .finish() // We're good to go!
     ///     }
     /// }
     ///
     /// assert_eq!(
     ///     format!("{:?}", Bar { bar: 10, another: "Hello World".to_string() }),
-    ///     "Bar { bar: 10, another: \"Hello World\", not_existing_field: 1 }",
+    ///     "Bar { bar: 10, another: \"Hello World\", nonexistent_field: 1 }",
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]

library/core/src/intrinsics.rs

@@ -2474,7 +2474,7 @@ extern "rust-intrinsic" {
 /// This macro should be called as `assert_unsafe_precondition!([Generics](name: Type) => Expression)`
 /// where the names specified will be moved into the macro as captured variables, and defines an item
 /// to call `const_eval_select` on. The tokens inside the square brackets are used to denote generics
-/// for the function declaractions and can be omitted if there is no generics.
+/// for the function declarations and can be omitted if there is no generics.
 ///
 /// # Safety
 ///
@@ -2733,7 +2733,7 @@ pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
     // SAFETY: the safety contract for `copy` must be upheld by the caller.
     unsafe {
         assert_unsafe_precondition!(
-            "ptr::copy requires that both pointer arguments are aligned aligned and non-null",
+            "ptr::copy requires that both pointer arguments are aligned and non-null",
             [T](src: *const T, dst: *mut T) =>
             is_aligned_and_not_null(src) && is_aligned_and_not_null(dst)
         );

library/core/src/macros/panic.md

@@ -42,7 +42,7 @@ the successful result of some computation, `Ok(T)`, or error types that
 represent an anticipated runtime failure mode of that computation, `Err(E)`.
 `Result` is used alongside user defined types which represent the various
 anticipated runtime failure modes that the associated computation could
-encounter. `Result` must be propagated manually, often with the the help of the
+encounter. `Result` must be propagated manually, often with the help of the
 `?` operator and `Try` trait, and they must be reported manually, often with
 the help of the `Error` trait.
 

library/core/src/ptr/const_ptr.rs

@@ -264,7 +264,7 @@ impl<T: ?Sized> *const T {
         let dest_addr = addr as isize;
         let offset = dest_addr.wrapping_sub(self_addr);
 
-        // This is the canonical desugarring of this operation
+        // This is the canonical desugaring of this operation
         self.wrapping_byte_offset(offset)
     }
 

library/core/src/ptr/mod.rs

@@ -2126,7 +2126,7 @@ mod new_fn_ptr_impl {
 /// assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);
 /// ```
 ///
-/// See [`addr_of_mut`] for how to create a pointer to unininitialized data.
+/// See [`addr_of_mut`] for how to create a pointer to uninitialized data.
 /// Doing that with `addr_of` would not make much sense since one could only
 /// read the data, and that would be Undefined Behavior.
 #[stable(feature = "raw_ref_macros", since = "1.51.0")]