rust-lang#66219 documented unsafe in core::cell

Author: foeb

src/libcore/cell.rs

@@ -187,8 +187,6 @@
 //! ```
 //!
 
-// ignore-tidy-undocumented-unsafe
-
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::cmp::Ordering;
@@ -369,6 +367,7 @@ impl<T> Cell<T> {
         if ptr::eq(self, other) {
             return;
         }
+        // SAFETY: Cell is not Sync
         unsafe {
             ptr::swap(self.value.get(), other.value.get());
         }
@@ -388,6 +387,7 @@ impl<T> Cell<T> {
     /// ```
     #[stable(feature = "move_cell", since = "1.17.0")]
     pub fn replace(&self, val: T) -> T {
+        // SAFETY: Cell is not Sync
         mem::replace(unsafe { &mut *self.value.get() }, val)
     }
 
@@ -424,6 +424,7 @@ impl<T:Copy> Cell<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get(&self) -> T {
+        // SAFETY: Cell is not Sync
         unsafe{ *self.value.get() }
     }
 
@@ -491,6 +492,7 @@ impl<T: ?Sized> Cell<T> {
     #[inline]
     #[stable(feature = "cell_get_mut", since = "1.11.0")]
     pub fn get_mut(&mut self) -> &mut T {
+        // SAFETY: &mut ensures unique access
         unsafe {
             &mut *self.value.get()
         }
@@ -512,6 +514,7 @@ impl<T: ?Sized> Cell<T> {
     #[inline]
     #[stable(feature = "as_cell", since = "1.37.0")]
     pub fn from_mut(t: &mut T) -> &Cell<T> {
+        // SAFETY: &mut ensures unique access
         unsafe {
             &*(t as *mut T as *const Cell<T>)
         }
@@ -557,6 +560,7 @@ impl<T> Cell<[T]> {
     /// ```
     #[stable(feature = "as_cell", since = "1.37.0")]
     pub fn as_slice_of_cells(&self) -> &[Cell<T>] {
+        // SAFETY: Cell<T> has the same memory layout as T
         unsafe {
             &*(self as *const Cell<[T]> as *const [Cell<T>])
         }
@@ -825,6 +829,8 @@ impl<T: ?Sized> RefCell<T> {
     pub fn try_borrow(&self) -> Result<Ref<'_, T>, BorrowError> {
         match BorrowRef::new(&self.borrow) {
             Some(b) => Ok(Ref {
+                // SAFETY: BorrowRef ensures that there is only immutable access to the value while
+                // borrowed
                 value: unsafe { &*self.value.get() },
                 borrow: b,
             }),
@@ -903,6 +909,7 @@ impl<T: ?Sized> RefCell<T> {
     pub fn try_borrow_mut(&self) -> Result<RefMut<'_, T>, BorrowMutError> {
         match BorrowRefMut::new(&self.borrow) {
             Some(b) => Ok(RefMut {
+                // SAFETY: BorrowRef gurantees unique access
                 value: unsafe { &mut *self.value.get() },
                 borrow: b,
             }),
@@ -954,6 +961,7 @@ impl<T: ?Sized> RefCell<T> {
     #[inline]
     #[stable(feature = "cell_get_mut", since = "1.11.0")]
     pub fn get_mut(&mut self) -> &mut T {
+        // SAFETY: &mut guarantees unique access
         unsafe {
             &mut *self.value.get()
         }

src/libcore/str/pattern.rs

@@ -352,7 +352,7 @@ unsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> {
     #[inline]
     fn next_back(&mut self) -> SearchStep {
         let old_finger = self.finger_back;
-        // 1. self.finger and self.old_finger are kept on unicode boundaries (this is invariant)
+        // 1. self.finger and self.finger_back are kept on unicode boundaries (this is invariant)
         // 2. self.finger >= 0 since it starts at 0 and only increases
         // 3. self.finger < self.finger_back because otherwise the char iter would return
         //    SearchStep::Done