Use Box::from_raw instead of ptr::drop_in_place as that actually dealloc's the Box (i'm dumb and misinterpreted the std code :/); fix some desync between code in between sections

Author: ThePuzzlemaker

src/arc-base.md

@@ -25,7 +25,8 @@ impl<T> Arc<T> {
             data,
         });
         Arc {
-            // It is okay to call `.unwrap()` here as we get a pointer from `Box::into_raw` which is guaranteed to not be null.
+            // It is okay to call `.unwrap()` here as we get a pointer from
+            // `Box::into_raw` which is guaranteed to not be null.
             ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
             _marker: PhantomData,
         }
@@ -84,8 +85,8 @@ impl<T> Arc<T> {
             data,
         });
         Arc {
-            // SOUNDNESS: It is sound to call `.unwrap()` here as we get a
-            // pointer from `Box::into_raw` which is guaranteed to not be null.
+            // It is okay to call `.unwrap()` here as we get a pointer from
+            // `Box::into_raw` which is guaranteed to not be null.
             ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
             _marker: PhantomData,
         }

src/arc-drop.md

@@ -63,14 +63,12 @@ We'll need to import `std::sync::atomic` itself:
 use std::sync::atomic;
 ```
 
-Finally, we can drop the data itself. We use `std::ptr::drop_in_place` as it is
-better than using `std::ptr::read` then dropping that object (see [its
-documentation](https://doc.rust-lang.org/stable/std/ptr/fn.drop_in_place.html)).
-This takes a `*mut T` and not a `NonNull<T>`, so we must convert using
-`NonNull::as_ptr`.
+Finally, we can drop the data itself. We use `Box::from_raw` to drop the boxed
+`ArcInner<T>` and its data. This takes a `*mut T` and not a `NonNull<T>`, so we
+must convert using `NonNull::as_ptr`.
 
 ```rust,ignore
-unsafe { std::ptr::drop_in_place(self.ptr.as_ptr()) }
+unsafe { stdBox::from_raw(self.ptr.as_ptr()) }
 ```
 
 This is safe as we know we have the last pointer to the `ArcInner` and that its
@@ -88,7 +86,7 @@ impl<T> Drop for Arc<T> {
         atomic::fence(Ordering::Acquire);
         // This is safe as we know we have the last pointer to the `ArcInner`
         // and that its pointer is valid.
-        unsafe { std::ptr::drop_in_place(self.ptr.as_ptr()) }
+        unsafe { Box::from_raw(self.ptr.as_ptr()) }
     }
 }
 ```

src/arc-final.md

@@ -26,16 +26,17 @@ impl<T> Arc<T> {
             data,
         });
         Arc {
-            // SOUNDNESS: It is sound to call `.unwrap()` here as we get a
-            // pointer from `Box::into_raw` which is guaranteed to not be null.
+            // It is okay to call `.unwrap()` here as we get a pointer from
+            // `Box::into_raw` which is guaranteed to not be null.
             ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
             _marker: PhantomData,
         }
     }
 
     fn inner(&self) -> &ArcInner<T> {
         // This unsafety is okay because while this Arc is alive, we're
-        // guaranteed that the inner pointer is valid.
+        // guaranteed that the inner pointer is valid. Also, ArcInner<T> is
+        // Sync if T is Sync.
         unsafe { self.ptr.as_ref() }
     }
 }
@@ -65,7 +66,7 @@ impl<T> Drop for Arc<T> {
         atomic::fence(Ordering::Acquire);
         // This is safe as we know we have the last pointer to the `ArcInner`
         // and that its pointer is valid.
-        unsafe { std::ptr::drop_in_place(self.ptr.as_ptr()) }
+        unsafe { Box::from_raw(self.ptr.as_ptr()) }
     }
 }