Apply suggestions from code review

Co-authored-by: Mark Rousskov <[email protected]>
Co-authored-by: Trevor Gross <[email protected]>

Author: 3 people

posts/2024-05-02-Rust-1.78.0.md

@@ -84,20 +84,21 @@ For more information, see the reference section on [the `diagnostic` tool attrib
 
 ### Asserting `unsafe` preconditions
 
-The Rust standard library has a number of assertions for the preconditions of `unsafe` functions, but historically they have only been enabled in `#[cfg(debug_assertions)]` builds to avoid affecting release performance. However, since the standard library is usually compiled and distributed in release mode, most Rust developers weren't ever executing these checks at all.
+The Rust standard library has a number of assertions for the preconditions of `unsafe` functions, but historically they have only been enabled in `#[cfg(debug_assertions)]` builds of the standard library to avoid affecting release performance. However, since the standard library is usually compiled and distributed in release mode, most Rust developers weren't ever executing these checks at all.
 
 Now, the condition for these assertions is delayed until code generation, so they will be checked depending on the user's own setting for debug assertions -- enabled by default in debug and test builds. This change helps users catch undefined behavior in their code, though the details of how much is checked are generally not stable.
 
-For example, [`slice::from_raw_parts`](https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html) requires an aligned non-null pointer. The following use of a purposely-misaligned pointer has undefined behavior, _which may or may not cause noticeable ill effect otherwise_, but the debug assertion can now catch it:
+For example, [`slice::from_raw_parts`](https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html) requires an aligned non-null pointer. The following use of a purposely-misaligned pointer has undefined behavior, and while that may not have obvious effects, the debug assertion can now catch it:
 
 ```rust
 fn main() {
     let slice: &[u8] = &[1, 2, 3, 4, 5];
-    let slice16: &[u16] = unsafe {
-        let ptr = slice.as_ptr();
-        let i = usize::from(ptr as usize & 1 == 0);
-        std::slice::from_raw_parts(ptr.add(i) as *const u16, 2)
-    };
+    let ptr = slice.as_ptr();
+
+    // Create an offset from `ptr` that will always be one off from `u16`'s correct alignment
+    let i = usize::from(ptr as usize & 1 == 0);
+    
+    let slice16: &[u16] = unsafe { std::slice::from_raw_parts(ptr.add(i).cast::<u16>(), 2) };
     dbg!(slice16);
 }
 ```