chore: fix typos (#3907)

tokio-util/src/codec/any_delimiter_codec.rs

@@ -234,7 +234,7 @@ impl Default for AnyDelimiterCodec {
     }
 }
 
-/// An error occured while encoding or decoding a chunk.
+/// An error occurred while encoding or decoding a chunk.
 #[derive(Debug)]
 pub enum AnyDelimiterCodecError {
     /// The maximum chunk length was exceeded.

tokio-util/src/codec/decoder.rs

@@ -28,7 +28,7 @@ use std::io;
 /// It is up to the Decoder to keep track of a restart after an EOF,
 /// and to decide how to handle such an event by, for example,
 /// allowing frames to cross EOF boundaries, re-emitting opening frames, or
-/// reseting the entire internal state.
+/// resetting the entire internal state.
 ///
 /// [`Framed`]: crate::codec::Framed
 /// [`FramedRead`]: crate::codec::FramedRead

tokio-util/src/codec/framed_impl.rs

@@ -124,7 +124,7 @@ where
         // to a combination of the `is_readable` and `eof` flags. States persist across
         // loop entries and most state transitions occur with a return.
         //
-        // The intitial state is `reading`.
+        // The initial state is `reading`.
         //
         // | state   | eof   | is_readable |
         // |---------|-------|-------------|
@@ -155,10 +155,10 @@ where
             // Both signal that there is no such data by returning `None`.
             //
             // If `decode` couldn't read a frame and the upstream source has returned eof,
-            // `decode_eof` will attemp to decode the remaining bytes as closing frames.
+            // `decode_eof` will attempt to decode the remaining bytes as closing frames.
             //
             // If the underlying AsyncRead is resumable, we may continue after an EOF,
-            // but must finish emmiting all of it's associated `decode_eof` frames.
+            // but must finish emitting all of it's associated `decode_eof` frames.
             // Furthermore, we don't want to emit any `decode_eof` frames on retried
             // reads after an EOF unless we've actually read more data.
             if state.is_readable {

tokio-util/src/codec/length_delimited.rs

@@ -486,7 +486,7 @@ impl LengthDelimitedCodec {
             // Skip the required bytes
             src.advance(self.builder.length_field_offset);
 
-            // match endianess
+            // match endianness
             let n = if self.builder.length_field_is_big_endian {
                 src.get_uint(field_len)
             } else {

tokio-util/src/codec/lines_codec.rs

@@ -203,12 +203,12 @@ impl Default for LinesCodec {
     }
 }
 
-/// An error occured while encoding or decoding a line.
+/// An error occurred while encoding or decoding a line.
 #[derive(Debug)]
 pub enum LinesCodecError {
     /// The maximum line length was exceeded.
     MaxLineLengthExceeded,
-    /// An IO error occured.
+    /// An IO error occurred.
     Io(io::Error),
 }
 

tokio-util/src/either.rs

@@ -67,7 +67,7 @@ pub enum Either<L, R> {
 }
 
 /// A small helper macro which reduces amount of boilerplate in the actual trait method implementation.
-/// It takes an invokation of method as an argument (e.g. `self.poll(cx)`), and redirects it to either
+/// It takes an invocation of method as an argument (e.g. `self.poll(cx)`), and redirects it to either
 /// enum variant held in `self`.
 macro_rules! delegate_call {
     ($self:ident.$method:ident($($args:ident),+)) => {

tokio-util/src/sync/cancellation_token.rs

@@ -775,8 +775,8 @@ impl CancellationTokenState {
             return Poll::Ready(());
         }
 
-        // So far the token is not cancelled. However it could be cancelld before
-        // we get the chance to store the `Waker`. Therfore we need to check
+        // So far the token is not cancelled. However it could be cancelled before
+        // we get the chance to store the `Waker`. Therefore we need to check
         // for cancellation again inside the mutex.
         let mut guard = self.synchronized.lock().unwrap();
         if guard.is_cancelled {

tokio-util/src/sync/intrusive_double_linked_list.rs

@@ -222,7 +222,7 @@ impl<T> LinkedList<T> {
         }
     }
 
-    /// Returns whether the linked list doesn not contain any node
+    /// Returns whether the linked list does not contain any node
     pub fn is_empty(&self) -> bool {
         if self.head.is_some() {
             return false;