more safety comments fixed or broken up

Author: nia-e

library/alloc/src/collections/btree/node.rs

@@ -86,13 +86,11 @@ impl<K, V> LeafNode<K, V> {
     /// Creates a new boxed `LeafNode`.
     fn new<A: Allocator + Clone>(alloc: A) -> Box<Self, A> {
         let mut leaf = Box::new_uninit_in(alloc);
-        // SAFETY: Untriaged.
-        unsafe {
-            // SAFETY: `leaf` points to a `LeafNode`
-            LeafNode::init(leaf.as_mut_ptr());
-            // SAFETY: `leaf` was just initialized
-            leaf.assume_init()
-        }
+
+        // SAFETY: `leaf` points to a `LeafNode`.
+        unsafe { LeafNode::init(leaf.as_mut_ptr()) };
+        // SAFETY: `leaf` was just initialized.
+        unsafe { leaf.assume_init() }
     }
 }
 
@@ -121,13 +119,11 @@ impl<K, V> InternalNode<K, V> {
     /// such an edge.
     unsafe fn new<A: Allocator + Clone>(alloc: A) -> Box<Self, A> {
         let mut node = Box::<Self, _>::new_uninit_in(alloc);
-        // SAFETY: Untriaged.
-        unsafe {
-            // SAFETY: argument points to the `node.data` `LeafNode`
-            LeafNode::init(&raw mut (*node.as_mut_ptr()).data);
-            // SAFETY: `node.data` was just initialized and `node.edges` is MaybeUninit.
-            node.assume_init()
-        }
+
+        // SAFETY: argument points to the `node.data` `LeafNode`.
+        unsafe { LeafNode::init(&raw mut (*node.as_mut_ptr()).data) };
+        // SAFETY: `node.data` was just initialized and `node.edges` is MaybeUninit.
+        unsafe { node.assume_init() }
     }
 }
 

library/alloc/src/collections/vec_deque/mod.rs

@@ -1324,9 +1324,10 @@ impl<T, A: Allocator> VecDeque<T, A> {
             //   [. . . . . . . . o o o o o o o . ]
             //    H           L
             //   [o o o o o o o . ]
-            // SAFETY: Untriaged.
+            //
+            // SAFETY: `self.head >= target_cap >= self.len`, therefore these accesses
+            // do not overlap.
             unsafe {
-                // nonoverlapping because `self.head >= target_cap >= self.len`.
                 self.copy_nonoverlapping(self.head, WrappedIndex::zero(), self.len);
             }
             self.head = WrappedIndex::zero();
@@ -1423,10 +1424,9 @@ impl<T, A: Allocator> VecDeque<T, A> {
             // There's enough spare capacity to copy the tail to the back (because `tail_len < self.capacity() - target_cap`),
             // and copying the tail should be cheaper than copying the head (because `tail_len <= head_len`).
 
-            // SAFETY: Untriaged.
+            // SAFETY: The old tail and the new tail can't overlap because the head slice lies
+            // between them. The head slice ends at `target_cap`, so that's where we copy to.
             unsafe {
-                // The old tail and the new tail can't overlap because the head slice lies between them. The
-                // head slice ends at `target_cap`, so that's where we copy to.
                 self.copy_nonoverlapping(
                     WrappedIndex::zero(),
                     WrappedIndex::from_arbitrary_number(target_cap),

library/alloc/src/io/cursor.rs

@@ -238,10 +238,9 @@ where
     let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
     let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
 
-    // Write the buf then progress the vec forward if necessary
-    // Safety: we have ensured that the capacity is available
+    // Write the buf then progress the vec forward if necessary.
+    // SAFETY: We have ensured that the capacity is available
     // and that all bytes get written up to the last pos
-    // SAFETY: Untriaged.
     unsafe {
         for buf in bufs {
             pos = vec_write_all_unchecked(pos, vec, buf);

library/alloc/src/vec/mod.rs

@@ -2695,14 +2695,15 @@ impl<T, A: Allocator> Vec<T, A> {
         let mut first_duplicate_idx: usize = 1;
         let start = self.as_mut_ptr();
         while first_duplicate_idx != len {
-            // SAFETY: Untriaged.
-            let found_duplicate = unsafe {
-                // SAFETY: first_duplicate always in range [1..len)
+            let found_duplicate = {
+                // SAFETY: first_duplicate always in range [1..len).
                 // Note that we start iteration from 1 so we never overflow.
-                let prev = start.add(first_duplicate_idx.wrapping_sub(1));
-                let current = start.add(first_duplicate_idx);
+                let prev = unsafe { start.add(first_duplicate_idx.wrapping_sub(1)) };
+                // SAFETY: Untriaged.
+                let current = unsafe { start.add(first_duplicate_idx) };
                 // We explicitly say in docs that references are reversed.
-                same_bucket(&mut *current, &mut *prev)
+                // SAFETY: Untriaged.
+                unsafe { same_bucket(&mut *current, &mut *prev) }
             };
             if found_duplicate {
                 break;