check ./library too

Author: klensy

library/alloc/src/fmt.rs

@@ -109,7 +109,7 @@
 //! parameters (corresponding to `format_spec` in [the syntax](#syntax)). These
 //! parameters affect the string representation of what's being formatted.
 //!
-//! The colon `:` in format syntax divides indentifier of the input data and
+//! The colon `:` in format syntax divides identifier of the input data and
 //! the formatting options, the colon itself does not change anything, only
 //! introduces the options.
 //!

library/core/src/future/async_drop.rs

@@ -41,7 +41,7 @@ impl<T> Future for AsyncDropOwning<T> {
             let dtor = Pin::new_unchecked(
                 this.dtor.get_or_insert_with(|| async_drop_in_place(this.value.as_mut_ptr())),
             );
-            // AsyncDestuctors are idempotent so Self gets idempotency as well
+            // AsyncDestructors are idempotent so Self gets idempotency as well
             dtor.poll(cx)
         }
     }
@@ -247,7 +247,7 @@ async unsafe fn either<O: IntoFuture<Output = ()>, M: IntoFuture<Output = ()>, T
     this: *mut T,
     discr: <T as DiscriminantKind>::Discriminant,
 ) {
-    // SAFETY: Guaranteed by the safety section of this funtion's documentation
+    // SAFETY: Guaranteed by the safety section of this function's documentation
     if unsafe { discriminant_value(&*this) } == discr {
         drop(other);
         matched.await

library/core/src/intrinsics/mod.rs

@@ -3836,7 +3836,7 @@ where
 /// used inside the `if const`.
 /// Note that the two arms of this `if` really each become their own function, which is why the
 /// macro supports setting attributes for those functions. The runtime function is always
-/// markes as `#[inline]`.
+/// marked as `#[inline]`.
 ///
 /// See [`const_eval_select()`] for the rules and requirements around that intrinsic.
 pub(crate) macro const_eval_select {

library/core/src/intrinsics/simd.rs

@@ -120,7 +120,7 @@ pub unsafe fn simd_shr<T>(_lhs: T, _rhs: T) -> T {
     unreachable!()
 }
 
-/// "Ands" vectors elementwise.
+/// "And"s vectors elementwise.
 ///
 /// `T` must be a vector of integer primitive types.
 #[rustc_intrinsic]
@@ -574,7 +574,7 @@ pub unsafe fn simd_reduce_min<T, U>(_x: T) -> U {
     unreachable!()
 }
 
-/// Logical "ands" all elements together.
+/// Logical "and"s all elements together.
 ///
 /// `T` must be a vector of integer or floating-point primitive types.
 ///

library/core/src/lib.rs

@@ -102,7 +102,7 @@
 #![allow(internal_features)]
 #![deny(ffi_unwind_calls)]
 #![warn(unreachable_pub)]
-// Do not check link redundancy on bootstraping phase
+// Do not check link redundancy on bootstrapping phase
 #![allow(rustdoc::redundant_explicit_links)]
 #![warn(rustdoc::unescaped_backticks)]
 //

library/core/src/pin.rs

@@ -792,7 +792,7 @@
 //!
 //! 1.  *Structural [`Unpin`].* A struct can be [`Unpin`] only if all of its
 //!     structurally-pinned fields are, too. This is [`Unpin`]'s behavior by default.
-//!     However, as a libray author, it is your responsibility not to write something like
+//!     However, as a library author, it is your responsibility not to write something like
 //!     <code>impl\<T> [Unpin] for Struct\<T> {}</code> and then offer a method that provides
 //!     structural pinning to an inner field of `T`, which may not be [`Unpin`]! (Adding *any*
 //!     projection operation requires unsafe code, so the fact that [`Unpin`] is a safe trait does

library/core/src/primitive_docs.rs

@@ -1628,8 +1628,8 @@ mod prim_ref {}
 /// let ptr: fn(usize) -> usize = add_one;
 /// assert_eq!(ptr(5), 6);
 ///
-/// let clos: fn(usize) -> usize = |x| x + 5;
-/// assert_eq!(clos(5), 10);
+/// let closure: fn(usize) -> usize = |x| x + 5;
+/// assert_eq!(closure(5), 10);
 /// ```
 ///
 /// In addition to varying based on their signature, function pointers come in two flavors: safe

library/core/src/ptr/const_ptr.rs

@@ -46,7 +46,7 @@ impl<T: ?Sized> *const T {
             if const #[rustc_allow_const_fn_unstable(const_raw_ptr_comparison)] {
                 match (ptr).guaranteed_eq(null_mut()) {
                     Some(res) => res,
-                    // To remain maximally convervative, we stop execution when we don't
+                    // To remain maximally conservative, we stop execution when we don't
                     // know whether the pointer is null or not.
                     // We can *not* return `false` here, that would be unsound in `NonNull::new`!
                     None => panic!("null-ness of this pointer cannot be determined in const context"),

library/panic_unwind/src/seh.rs

@@ -264,7 +264,7 @@ static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
 // runtime under a try/catch block and the panic that we generate here will be
 // used as the result of the exception copy. This is used by the C++ runtime to
 // support capturing exceptions with std::exception_ptr, which we can't support
-// because Box<dyn Any> isn't clonable.
+// because Box<dyn Any> isn't cloneable.
 macro_rules! define_cleanup {
     ($abi:tt $abi2:tt) => {
         unsafe extern $abi fn exception_cleanup(e: *mut Exception) {

library/std/src/sys/net/connection/socket/wasip2.rs

@@ -141,7 +141,7 @@ impl Socket {
                 0 => {}
                 _ => {
                     // WASI poll does not return  POLLHUP or POLLERR in revents. Check if the
-                    // connnection actually succeeded and return ok only when the socket is
+                    // connection actually succeeded and return ok only when the socket is
                     // ready and no errors were found.
                     if let Some(e) = self.take_error()? {
                         return Err(e);