Fix spelling in documentation (#2733)

Author: jbcrail

src/error.rs

@@ -249,7 +249,7 @@ where
 pub struct AlignmentError<Src, Dst: ?Sized> {
     /// The source value involved in the conversion.
     src: Src,
-    /// The inner destination type inolved in the conversion.
+    /// The inner destination type involved in the conversion.
     ///
     /// INVARIANT: An `AlignmentError` may only be constructed if `Dst`'s
     /// alignment requirement is greater than one.

src/lib.rs

@@ -630,7 +630,7 @@ use {FromZeros as FromZeroes, IntoBytes as AsBytes, Ref as LayoutVerified};
 /// example.
 ///
 /// A `#[repr(C)]` slice DST is laid out [just like sized `#[repr(C)]`
-/// types][repr-c-structs], but the presenence of a variable-length field
+/// types][repr-c-structs], but the presence of a variable-length field
 /// introduces the possibility of *dynamic padding*. In particular, it may be
 /// necessary to add trailing padding *after* the trailing slice field in order
 /// to satisfy the outer type's alignment, and the amount of padding required
@@ -1446,7 +1446,7 @@ pub use zerocopy_derive::TryFromBytes;
 /// definitely invalid.
 ///
 /// Zerocopy takes a conservative approach, and only considers a bit pattern to
-/// be valid if its validity is a documenteed guarantee provided by the
+/// be valid if its validity is a documented guarantee provided by the
 /// language.
 ///
 /// For most use cases, Rust's current guarantees align with programmers'

src/macros.rs

@@ -101,7 +101,7 @@ macro_rules! transmute {
                 dst: ManuallyDrop<Dst>,
             }
 
-            // SAFETY: `Transmute` is a `reper(C)` union whose `src` field has
+            // SAFETY: `Transmute` is a `repr(C)` union whose `src` field has
             // type `ManuallyDrop<Src>`. Thus, the `src` field starts at byte
             // offset 0 within `Transmute` [1]. `ManuallyDrop<T>` has the same
             // layout and bit validity as `T`, so it is sound to transmute `Src`

src/pointer/ptr.rs

@@ -815,7 +815,7 @@ mod _transitions {
                 // contains a bit-valid instance of `T`. By `T:
                 // TryTransmuteFromPtr<T, I::Aliasing, I::Validity, Valid>`, so
                 // long as `self`'s referent conforms to the `Valid` validity
-                // for `T` (which we just confired), then this transmute is
+                // for `T` (which we just confirmed), then this transmute is
                 // sound.
                 Ok(unsafe { self.assume_valid() })
             } else {

src/ref.rs

@@ -717,7 +717,7 @@ where
         let b = unsafe { r.as_byte_slice() };
 
         // SAFETY: By postcondition on `as_byte_slice`, we know that `b` is a
-        // valid size and ailgnment for `T`. By safety invariant on `ByteSlice`,
+        // valid size and alignment for `T`. By safety invariant on `ByteSlice`,
         // we know that this is preserved via `.deref()`. Because `T:
         // FromBytes`, it is sound to interpret these bytes as a `T`.
         unsafe { ptr::read(b.deref().as_ptr().cast::<T>()) }
@@ -741,7 +741,7 @@ where
         let b = unsafe { r.as_byte_slice_mut() };
 
         // SAFETY: By postcondition on `as_byte_slice_mut`, we know that `b` is
-        // a valid size and ailgnment for `T`. By safety invariant on
+        // a valid size and alignment for `T`. By safety invariant on
         // `ByteSlice`, we know that this is preserved via `.deref()`. Writing
         // `t` to the buffer will allow all of the bytes of `t` to be accessed
         // as a `[u8]`, but because `T: IntoBytes`, we know that this is sound.

src/util/mod.rs

@@ -281,7 +281,7 @@ pub(crate) const unsafe fn transmute_unchecked<Src, Dst>(src: Src) -> Dst {
     // SAFETY: Since `Transmute<Src, Dst>` is `#[repr(C)]`, its `src` and `dst`
     // fields both start at the same offset and the types of those fields are
     // transparent wrappers around `Src` and `Dst` [1]. Consequently,
-    // initializng `Transmute` with with `src` and then reading out `dst` is
+    // initializing `Transmute` with with `src` and then reading out `dst` is
     // equivalent to transmuting from `Src` to `Dst` [2]. Transmuting from `src`
     // to `Dst` is valid because — by contract on the caller — `src` is a valid
     // instance of `Dst`.