Fix a bunch of typos

library/alloc/tests/boxed.rs

@@ -3,7 +3,7 @@ use std::mem::MaybeUninit;
 use std::ptr::NonNull;
 
 #[test]
-fn unitialized_zero_size_box() {
+fn uninitialized_zero_size_box() {
  assert_eq!(
  &*Box::<()>::new_uninit() as *const _,
  NonNull::<MaybeUninit<()>>::dangling().as_ptr(),

library/alloc/tests/str.rs

@@ -162,7 +162,7 @@ fn test_join_for_different_lengths_with_long_separator() {
 }
 
 #[test]
-fn test_join_isue_80335() {
+fn test_join_issue_80335() {
  use core::{borrow::Borrow, cell::Cell};
 
  struct WeirdBorrow {

library/core/src/alloc/layout.rs

@@ -157,11 +157,11 @@ impl Layout {
  ///
  /// - If `T` is `Sized`, this function is always safe to call.
  /// - If the unsized tail of `T` is:
- /// - a [slice], then the length of the slice tail must be an intialized
+ /// - a [slice], then the length of the slice tail must be an initialized
  /// integer, and the size of the *entire value*
  /// (dynamic tail length + statically sized prefix) must fit in `isize`.
  /// - a [trait object], then the vtable part of the pointer must point
- /// to a valid vtable for the type `T` acquired by an unsizing coersion,
+ /// to a valid vtable for the type `T` acquired by an unsizing coercion,
  /// and the size of the *entire value*
  /// (dynamic tail length + statically sized prefix) must fit in `isize`.
  /// - an (unstable) [extern type], then this function is always safe to

library/core/src/cell.rs

@@ -898,7 +898,7 @@ impl<T: ?Sized> RefCell<T> {
  Ok(Ref { value: unsafe { &*self.value.get() }, borrow: b })
  }
  None => Err(BorrowError {
- // If a borrow occured, then we must already have an outstanding borrow,
+ // If a borrow occurred, then we must already have an outstanding borrow,
  // so `borrowed_at` will be `Some`
  #[cfg(feature = "debug_refcell")]
  location: self.borrowed_at.get().unwrap(),
@@ -983,7 +983,7 @@ impl<T: ?Sized> RefCell<T> {
  Ok(RefMut { value: unsafe { &mut *self.value.get() }, borrow: b })
  }
  None => Err(BorrowMutError {
- // If a borrow occured, then we must already have an outstanding borrow,
+ // If a borrow occurred, then we must already have an outstanding borrow,
  // so `borrowed_at` will be `Some`
  #[cfg(feature = "debug_refcell")]
  location: self.borrowed_at.get().unwrap(),
@@ -1104,7 +1104,7 @@ impl<T: ?Sized> RefCell<T> {
  Ok(unsafe { &*self.value.get() })
  } else {
  Err(BorrowError {
- // If a borrow occured, then we must already have an outstanding borrow,
+ // If a borrow occurred, then we must already have an outstanding borrow,
  // so `borrowed_at` will be `Some`
  #[cfg(feature = "debug_refcell")]
  location: self.borrowed_at.get().unwrap(),

library/core/src/iter/adapters/zip.rs

@@ -517,7 +517,7 @@ impl<A: Debug + TrustedRandomAccessNoCoerce, B: Debug + TrustedRandomAccessNoCoe
 /// * It must also be safe to drop `self` after calling `self.__iterator_get_unchecked(idx)`.
 /// * If `T` is a subtype of `Self`, then it must be safe to coerce `self` to `T`.
 //
-// FIXME: Clarify interaction with SourceIter/InPlaceIterable. Calling `SouceIter::as_inner`
+// FIXME: Clarify interaction with SourceIter/InPlaceIterable. Calling `SourceIter::as_inner`
 // after `__iterator_get_unchecked` is supposed to be allowed.
 #[doc(hidden)]
 #[unstable(feature = "trusted_random_access", issue = "none")]

library/core/src/iter/range.rs

@@ -777,7 +777,7 @@ range_exact_iter_impl! {
  usize u8 u16
  isize i8 i16
 
- // These are incorect per the reasoning above,
+ // These are incorrect per the reasoning above,
  // but removing them would be a breaking change as they were stabilized in Rust 1.0.0.
  // So e.g. `(0..66_000_u32).len()` for example will compile without error or warnings
  // on 16-bit platforms, but continue to give a wrong result.
@@ -805,7 +805,7 @@ range_incl_exact_iter_impl! {
  u8
  i8
 
- // These are incorect per the reasoning above,
+ // These are incorrect per the reasoning above,
  // but removing them would be a breaking change as they were stabilized in Rust 1.26.0.
  // So e.g. `(0..=u16::MAX).len()` for example will compile without error or warnings
  // on 16-bit platforms, but continue to give a wrong result.

library/core/src/num/dec2flt/number.rs

@@ -40,7 +40,7 @@ impl Number {
  && !self.many_digits
  }
 
- /// The fast path algorithmn using machine-sized integers and floats.
+ /// The fast path algorithm using machine-sized integers and floats.
  ///
  /// This is extracted into a separate function so that it can be attempted before constructing
  /// a Decimal. This only works if both the mantissa and the exponent

library/core/src/num/fmt.rs

@@ -1,4 +1,4 @@
-//! Shared utilties used by both float and integer formatting.
+//! Shared utilities used by both float and integer formatting.
 #![doc(hidden)]
 #![unstable(
  feature = "numfmt",

library/core/src/slice/iter.rs

@@ -221,7 +221,7 @@ impl<'a, T> IterMut<'a, T> {
  // the length, to also allows for the fast `ptr == end` check.
  //
  // See the `next_unchecked!` and `is_empty!` macros as well as the
- // `post_inc_start` method for more informations.
+ // `post_inc_start` method for more information.
  unsafe {
  assume(!ptr.is_null());
 

library/core/src/slice/rotate.rs

@@ -104,7 +104,7 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  // - overflows cannot happen for `i` since the function's safety contract ask for
  // `mid+right-1 = x+left+right` to be valid for writing
  // - underflows cannot happen because `i` must be bigger or equal to `left` for
- // a substraction of `left` to happen.
+ // a subtraction of `left` to happen.
  //
  // So `x+i` is valid for reading and writing if the caller respected the contract
  tmp = unsafe { x.add(i).replace(tmp) };
@@ -202,7 +202,7 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  loop {
  // SAFETY:
  // `left >= right` so `[mid-right, mid+right)` is valid for reading and writing
- // Substracting `right` from `mid` each turn is counterbalanced by the addition and
+ // Subtracting `right` from `mid` each turn is counterbalanced by the addition and
  // check after it.
  unsafe {
  ptr::swap_nonoverlapping(mid.sub(right), mid, right);
@@ -218,7 +218,7 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  loop {
  // SAFETY: `[mid-left, mid+left)` is valid for reading and writing because
  // `left < right` so `mid+left < mid+right`.
- // Adding `left` to `mid` each turn is counterbalanced by the substraction and check
+ // Adding `left` to `mid` each turn is counterbalanced by the subtraction and check
  // after it.
  unsafe {
  ptr::swap_nonoverlapping(mid.sub(left), mid, left);

library/core/src/str/iter.rs

@@ -748,7 +748,7 @@ generate_pattern_iterators! {
 }
 
 impl<'a, P: Pattern<'a>> Split<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -769,7 +769,7 @@ impl<'a, P: Pattern<'a>> Split<'a, P> {
 }
 
 impl<'a, P: Pattern<'a>> RSplit<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -808,7 +808,7 @@ generate_pattern_iterators! {
 }
 
 impl<'a, P: Pattern<'a>> SplitTerminator<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -829,7 +829,7 @@ impl<'a, P: Pattern<'a>> SplitTerminator<'a, P> {
 }
 
 impl<'a, P: Pattern<'a>> RSplitTerminator<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -931,7 +931,7 @@ generate_pattern_iterators! {
 }
 
 impl<'a, P: Pattern<'a>> SplitN<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -952,7 +952,7 @@ impl<'a, P: Pattern<'a>> SplitN<'a, P> {
 }
 
 impl<'a, P: Pattern<'a>> RSplitN<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -1236,7 +1236,7 @@ impl<'a> DoubleEndedIterator for SplitWhitespace<'a> {
 impl FusedIterator for SplitWhitespace<'_> {}
 
 impl<'a> SplitWhitespace<'a> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -1292,7 +1292,7 @@ impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a> {
 impl FusedIterator for SplitAsciiWhitespace<'_> {}
 
 impl<'a> SplitAsciiWhitespace<'a> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///
@@ -1360,7 +1360,7 @@ impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
 impl<'a, P: Pattern<'a>> FusedIterator for SplitInclusive<'a, P> {}
 
 impl<'a, P: Pattern<'a>> SplitInclusive<'a, P> {
- /// Returns remainder of the splitted string
+ /// Returns remainder of the split string
  ///
  /// # Examples
  ///

library/core/tests/array.rs

@@ -259,7 +259,7 @@ fn iterator_drops() {
 // This test does not work on targets without panic=unwind support.
 // To work around this problem, test is marked is should_panic, so it will
 // be automagically skipped on unsuitable targets, such as
-// wasm32-unknown-unkown.
+// wasm32-unknown-unknown.
 //
 // It means that we use panic for indicating success.
 #[test]

library/panic_unwind/src/emcc.rs

@@ -49,7 +49,7 @@ static EXCEPTION_TYPE_INFO: TypeInfo = TypeInfo {
 };
 
 struct Exception {
- // This is necessary because C++ code can capture our execption with
+ // This is necessary because C++ code can capture our exception with
  // std::exception_ptr and rethrow it multiple times, possibly even in
  // another thread.
  caught: AtomicBool,

library/std/src/fs/tests.rs

@@ -1369,7 +1369,7 @@ fn symlink_hard_link() {
  // "hard_link" should appear as a symlink.
  assert!(check!(fs::symlink_metadata(tmpdir.join("hard_link"))).file_type().is_symlink());
 
- // We sould be able to open "file" via any of the above names.
+ // We should be able to open "file" via any of the above names.
  let _ = check!(fs::File::open(tmpdir.join("file")));
  assert!(fs::File::open(tmpdir.join("file.renamed")).is_err());
  let _ = check!(fs::File::open(tmpdir.join("symlink")));

library/std/src/io/mod.rs

@@ -362,15 +362,15 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>
  let start_len = buf.len();
  let start_cap = buf.capacity();
 
- let mut initialized = 0; // Extra initalized bytes from previous loop iteration
+ let mut initialized = 0; // Extra initialized bytes from previous loop iteration
  loop {
  if buf.len() == buf.capacity() {
  buf.reserve(32); // buf is full, need more space
  }
 
  let mut read_buf = ReadBuf::uninit(buf.spare_capacity_mut());
 
- // SAFETY: These bytes were initalized but not filled in the previous loop
+ // SAFETY: These bytes were initialized but not filled in the previous loop
  unsafe {
  read_buf.assume_init(initialized);
  }

library/std/src/io/stdio.rs

@@ -1179,7 +1179,7 @@ where
  })
  }) == Ok(Some(()))
  {
- // Succesfully wrote to capture buffer.
+ // Successfully wrote to capture buffer.
  return;
  }
 

library/std/src/net/ip/tests.rs

@@ -749,7 +749,7 @@ fn ipv4_from_constructors() {
 }
 
 #[test]
-fn ipv6_from_contructors() {
+fn ipv6_from_constructors() {
  assert_eq!(Ipv6Addr::LOCALHOST, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
  assert!(Ipv6Addr::LOCALHOST.is_loopback());
  assert_eq!(Ipv6Addr::UNSPECIFIED, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));

library/std/src/panicking.rs

@@ -365,7 +365,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
  // The call to `intrinsics::r#try` is made safe by:
  // - `do_call`, the first argument, can be called with the initial `data_ptr`.
  // - `do_catch`, the second argument, can be called with the `data_ptr` as well.
- // See their safety preconditions for more informations
+ // See their safety preconditions for more information
  unsafe {
  return if intrinsics::r#try(do_call::<F, R>, data_ptr, do_catch::<F, R>) == 0 {
  Ok(ManuallyDrop::into_inner(data.r))
@@ -398,7 +398,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
  // expects normal function pointers.
  #[inline]
  fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {
- // SAFETY: this is the responsibilty of the caller, see above.
+ // SAFETY: this is the responsibility of the caller, see above.
  unsafe {
  let data = data as *mut Data<F, R>;
  let data = &mut (*data);
@@ -420,7 +420,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
  // expects normal function pointers.
  #[inline]
  fn do_catch<F: FnOnce() -> R, R>(data: *mut u8, payload: *mut u8) {
- // SAFETY: this is the responsibilty of the caller, see above.
+ // SAFETY: this is the responsibility of the caller, see above.
  //
  // When `__rustc_panic_cleaner` is correctly implemented we can rely
  // on `obj` being the correct thing to pass to `data.p` (after wrapping

library/std/src/sys/itron/thread.rs

@@ -126,7 +126,7 @@ impl Thread {
  // In this case, `inner`'s ownership has been moved to us,
  // And we are responsible for dropping it. The acquire
  // ordering is not necessary because the parent thread made
- // no memory acccess needing synchronization since the call
+ // no memory access needing synchronization since the call
  // to `acre_tsk`.
  // Safety: See above.
  let _ = unsafe { Box::from_raw(inner as *const _ as *mut ThreadInner) };
@@ -264,7 +264,7 @@ impl Drop for Thread {
  // one will ever join it.
  // The ownership of `self.inner` is moved to the child thread.
  // However, the release ordering is not necessary because we
- // made no memory acccess needing synchronization since the call
+ // made no memory access needing synchronization since the call
  // to `acre_tsk`.
  }
  LIFECYCLE_FINISHED => {

library/std/src/sys/unix/kernel_copy.rs

@@ -104,7 +104,7 @@ impl FdMeta {
 
  fn potential_sendfile_source(&self) -> bool {
  match self {
- // procfs erronously shows 0 length on non-empty readable files.
+ // procfs erroneously shows 0 length on non-empty readable files.
  // and if a file is truly empty then a `read` syscall will determine that and skip the write syscall
  // thus there would be benefit from attempting sendfile
  FdMeta::Metadata(meta)

library/std/src/sys/unix/process/process_fuchsia.rs

@@ -284,7 +284,7 @@ impl ExitStatus {
  //
  // The other view would be to say that the caller on Fuchsia ought to know that `into_raw`
  // will give a raw Fuchsia status (whatever that is - I don't know, personally). That is
- // not possible here becaause we must return a c_int because that's what Unix (including
+ // not possible here because we must return a c_int because that's what Unix (including
  // SuS and POSIX) say a wait status is, but Fuchsia apparently uses a u64, so it won't
  // necessarily fit.
  //

library/std/src/sys/unix/weak.rs

@@ -124,7 +124,7 @@ impl<F> DlsymWeak<F> {
  }
  }
 
- // Cold because it should only happen during first-time initalization.
+ // Cold because it should only happen during first-time initialization.
  #[cold]
  unsafe fn initialize(&self) -> Option<F> {
  assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>());

library/std/src/sys/wasm/alloc.rs

@@ -24,31 +24,31 @@ static mut DLMALLOC: dlmalloc::Dlmalloc = dlmalloc::Dlmalloc::new();
 unsafe impl GlobalAlloc for System {
  #[inline]
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
- // SAFETY: DLMALLOC access is guranteed to be safe because the lock gives us unique and non-reentrant access.
+ // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
  // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
  let _lock = lock::lock();
  unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
  }
 
  #[inline]
  unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
- // SAFETY: DLMALLOC access is guranteed to be safe because the lock gives us unique and non-reentrant access.
+ // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
  // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
  let _lock = lock::lock();
  unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
  }
 
  #[inline]
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
- // SAFETY: DLMALLOC access is guranteed to be safe because the lock gives us unique and non-reentrant access.
+ // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
  // Calling free() is safe because preconditions on this function match the trait method preconditions.
  let _lock = lock::lock();
  unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
  }
 
  #[inline]
  unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
- // SAFETY: DLMALLOC access is guranteed to be safe because the lock gives us unique and non-reentrant access.
+ // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
  // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
  let _lock = lock::lock();
  unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }