Fix typos (#2551)

Author: jplatte

rustfmt.toml

@@ -8,7 +8,7 @@
 
 edition = "2021"
 
-# The "Default" setting has a heuristic which splits lines too aggresively.
+# The "Default" setting has a heuristic which splits lines too aggressively.
 # We are willing to revisit this setting in future versions of rustfmt.
 # Bugs:
 #   * https://github.com/rust-lang/rustfmt/issues/3119

src/byte_slice.rs

@@ -112,7 +112,7 @@ pub unsafe trait SplitByteSlice: ByteSlice {
         if mid <= self.deref().len() {
             // SAFETY: Above, we ensure that `mid <= self.deref().len()`. By
             // invariant on `ByteSlice`, a supertrait of `SplitByteSlice`,
-            // `.deref()` is guranteed to be "stable"; i.e., it will always
+            // `.deref()` is guaranteed to be "stable"; i.e., it will always
             // dereference to a byte slice of the same address and length. Thus,
             // we can be sure that the above precondition remains satisfied
             // through the call to `split_at_unchecked`.

src/layout.rs

@@ -299,7 +299,7 @@ impl DstLayout {
                     SizeInfo::Sized { size: field_size } => {
                         // If the trailing field is sized, the resulting layout
                         // will be sized. Its size will be the sum of the
-                        // preceeding layout, the size of the new field, and the
+                        // preceding layout, the size of the new field, and the
                         // size of inter-field padding between the two.
                         //
                         // This will not panic (and is proven with Kani to not
@@ -1050,7 +1050,7 @@ mod tests {
                 };
 
                 // If a cast is invalid, it is either because...
-                // 1. there are insufficent bytes at the given region for type:
+                // 1. there are insufficient bytes at the given region for type:
                 let insufficient_bytes = bytes_len < min_size;
                 // 2. performing the cast would misalign type:
                 let base = match cast_type {

src/lib.rs

@@ -5214,12 +5214,12 @@ pub unsafe trait IntoBytes {
     /// ```
     /// # use zerocopy::IntoBytes;
     /// # let header = u128::MAX;
-    /// let mut insufficent_bytes = &mut [0, 0][..];
+    /// let mut insufficient_bytes = &mut [0, 0][..];
     ///
-    /// let write_result = header.write_to_suffix(insufficent_bytes);
+    /// let write_result = header.write_to_suffix(insufficient_bytes);
     ///
     /// assert!(write_result.is_err());
-    /// assert_eq!(insufficent_bytes, [0, 0]);
+    /// assert_eq!(insufficient_bytes, [0, 0]);
     /// ```
     #[must_use = "callers should check the return value to see if the operation succeeded"]
     #[inline]
@@ -5276,12 +5276,12 @@ pub unsafe trait IntoBytes {
     ///
     /// assert_eq!(bytes, [0, 0, 0, 1, 2, 3, 4, 5, 6, 7]);
     ///
-    /// let mut insufficent_bytes = &mut [0, 0][..];
+    /// let mut insufficient_bytes = &mut [0, 0][..];
     ///
-    /// let write_result = header.write_to_suffix(insufficent_bytes);
+    /// let write_result = header.write_to_suffix(insufficient_bytes);
     ///
     /// assert!(write_result.is_err());
-    /// assert_eq!(insufficent_bytes, [0, 0]);
+    /// assert_eq!(insufficient_bytes, [0, 0]);
     /// ```
     ///
     /// If insufficient target bytes are provided, `write_to_suffix` returns
@@ -5290,12 +5290,12 @@ pub unsafe trait IntoBytes {
     /// ```
     /// # use zerocopy::IntoBytes;
     /// # let header = u128::MAX;
-    /// let mut insufficent_bytes = &mut [0, 0][..];
+    /// let mut insufficient_bytes = &mut [0, 0][..];
     ///
-    /// let write_result = header.write_to_suffix(insufficent_bytes);
+    /// let write_result = header.write_to_suffix(insufficient_bytes);
     ///
     /// assert!(write_result.is_err());
-    /// assert_eq!(insufficent_bytes, [0, 0]);
+    /// assert_eq!(insufficient_bytes, [0, 0]);
     /// ```
     #[must_use = "callers should check the return value to see if the operation succeeded"]
     #[inline]
@@ -5355,7 +5355,7 @@ pub unsafe trait IntoBytes {
     /// ```
     ///
     /// If the write fails, `write_to_io` returns `Err` and a partial write may
-    /// have occured; e.g.:
+    /// have occurred; e.g.:
     ///
     /// ```
     /// # use zerocopy::IntoBytes;
@@ -5559,7 +5559,7 @@ pub unsafe trait Unaligned {
 /// The standard library's [`derive(Hash)`][derive@Hash] produces hashes by
 /// individually hashing each field and combining the results. Instead, the
 /// implementations of [`Hash::hash()`] and [`Hash::hash_slice()`] generated by
-/// `derive(ByteHash)` convert the entirey of `self` to a byte slice and hashes
+/// `derive(ByteHash)` convert the entirety of `self` to a byte slice and hashes
 /// it in a single call to [`Hasher::write()`]. This may have performance
 /// advantages.
 ///
@@ -5597,7 +5597,7 @@ pub use zerocopy_derive::ByteHash;
 ///
 /// The standard library's [`derive(Eq, PartialEq)`][derive@PartialEq] computes
 /// equality by individually comparing each field. Instead, the implementation
-/// of [`PartialEq::eq`] emitted by `derive(ByteHash)` converts the entirey of
+/// of [`PartialEq::eq`] emitted by `derive(ByteHash)` converts the entirety of
 /// `self` and `other` to byte slices and compares those slices for equality.
 /// This may have performance advantages.
 #[cfg(any(feature = "derive", test))]

src/pointer/invariant.rs

@@ -145,7 +145,7 @@ unsafe impl Validity for Uninit {}
 /// Formally: uninitialized bytes may only be present in `Ptr<T>`'s referent
 /// where they are guaranteed to be present in `T`. This is a dynamic property:
 /// if, at a particular byte offset, a valid enum discriminant is set, the
-/// subsequent bytes may only have uninitialized bytes as specificed by the
+/// subsequent bytes may only have uninitialized bytes as specified by the
 /// corresponding enum.
 ///
 /// Formally, given `len = size_of_val_raw(ptr)`, at every byte offset, `b`, in
@@ -201,7 +201,7 @@ unsafe impl<ST: ?Sized, DT: ?Sized> CastableFrom<ST, Initialized, Initialized> f
 /// [`Ptr`](crate::Ptr) referents that permit unsynchronized read operations.
 ///
 /// `T: Read<A, R>` implies that a pointer to `T` with aliasing `A` permits
-/// unsynchronized read oeprations. This can be because `A` is [`Exclusive`] or
+/// unsynchronized read operations. This can be because `A` is [`Exclusive`] or
 /// because `T` does not permit interior mutation.
 ///
 /// # Safety

src/ref.rs

@@ -588,7 +588,7 @@ where
         } else {
             return Err(SizeError::new(source).into());
         };
-        // SAFETY: The preceeding `source.len().checked_sub(expected_len)`
+        // SAFETY: The preceding `source.len().checked_sub(expected_len)`
         // guarantees that `split_at` is in-bounds.
         let (bytes, suffix) = unsafe { source.split_at_unchecked(split_at) };
         Self::from_bytes(suffix).map(move |l| (bytes, l))
@@ -883,7 +883,7 @@ mod tests {
     #[test]
     fn test_mut_slice_into_ref() {
         // Prior to #1260/#1299, calling `into_ref` on a `&mut [u8]`-backed
-        // `Ref` was not supportd.
+        // `Ref` was not supported.
         let mut buf = [0u8];
         let r = Ref::<&mut [u8], u8>::from_bytes(&mut buf).unwrap();
         assert_eq!(Ref::into_ref(r), &0);

src/split_at.rs

@@ -765,7 +765,7 @@ where
         if l_len.padding_needed_for() == 0 {
             // SAFETY: By `T: SplitAt`, `T` is either `[T]`, or a `repr(C)` or
             // `repr(transparent)` slice DST, for which the trailing padding
-            // needed to accomodate `l_len` trailing elements is
+            // needed to accommodate `l_len` trailing elements is
             // `l_len.padding_needed_for()`. If no trailing padding is required,
             // the left and right parts are strictly non-overlapping.
             Ok(unsafe { self.via_unchecked() })

src/util/macro_util.rs

@@ -264,7 +264,7 @@ macro_rules! align_of {
         // correctly-align the entire struct.
         //
         // This macro computes the alignment of `$ty` by counting the number of
-        // bytes preceeding `_trailing`. For instance, if the alignment of `$ty`
+        // bytes preceding `_trailing`. For instance, if the alignment of `$ty`
         // is `1`, then no padding is required align `_trailing` and it will be
         // located immediately after `_byte` at offset 1. If the alignment of
         // `$ty` is 2, then a single padding byte is required before

src/util/macros.rs

@@ -249,7 +249,7 @@ macro_rules! impl_for_transmute_from {
     };
 }
 
-/// Implements a trait for a type, bounding on each memeber of the power set of
+/// Implements a trait for a type, bounding on each member of the power set of
 /// a set of type variables. This is useful for implementing traits for tuples
 /// or `fn` types.
 ///

src/util/mod.rs

@@ -739,7 +739,7 @@ pub(crate) mod testutil {
     /// A `T` which is guaranteed not to satisfy `align_of::<A>()`.
     ///
     /// It must be the case that `align_of::<T>() < align_of::<A>()` in order
-    /// fot this type to work properly.
+    /// for this type to work properly.
     #[repr(C)]
     pub(crate) struct ForceUnalign<T: Unaligned, A> {
         // The outer struct is aligned to `A`, and, thanks to `repr(C)`, `t` is