implicit_unsafe_autorefs: more std fixes

Author: WaffleLapkin

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

@@ -544,7 +544,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
     fn set_parent_link(&mut self, parent: NonNull<InternalNode<K, V>>, parent_idx: usize) {
         let leaf = Self::as_leaf_ptr(self);
         unsafe { (*leaf).parent = Some(parent) };
-        unsafe { (*leaf).parent_idx.write(parent_idx as u16) };
+        unsafe { (*leaf).parent_idx = MaybeUninit::new(parent_idx as u16) };
     }
 }
 

library/alloc/src/rc.rs

@@ -457,9 +457,9 @@ impl<T> Rc<T> {
             let inner = init_ptr.as_ptr();
             ptr::write(ptr::addr_of_mut!((*inner).value), data);
 
-            let prev_value = (*inner).strong.get();
+            let prev_value = (&(*inner).strong).get();
             debug_assert_eq!(prev_value, 0, "No prior strong references should exist");
-            (*inner).strong.set(1);
+            (&mut (*inner).strong).set(1);
 
             Rc::from_inner(init_ptr)
         };

library/alloc/src/sync.rs

@@ -456,7 +456,7 @@ impl<T> Arc<T> {
             //
             // These side effects do not impact us in any way, and no other side effects are
             // possible with safe code alone.
-            let prev_value = (*inner).strong.fetch_add(1, Release);
+            let prev_value = (&(*inner).strong).fetch_add(1, Release);
             debug_assert_eq!(prev_value, 0, "No prior strong references should exist");
 
             Arc::from_inner(init_ptr)

library/std/src/sync/mpsc/mpsc_queue.rs

@@ -70,7 +70,7 @@ impl<T> Queue<T> {
         unsafe {
             let n = Node::new(Some(t));
             let prev = self.head.swap(n, Ordering::AcqRel);
-            (*prev).next.store(n, Ordering::Release);
+            (&(*prev).next).store(n, Ordering::Release);
         }
     }
 
@@ -87,13 +87,13 @@ impl<T> Queue<T> {
     pub fn pop(&self) -> PopResult<T> {
         unsafe {
             let tail = *self.tail.get();
-            let next = (*tail).next.load(Ordering::Acquire);
+            let next = (&(*tail).next).load(Ordering::Acquire);
 
             if !next.is_null() {
                 *self.tail.get() = next;
-                assert!((*tail).value.is_none());
-                assert!((*next).value.is_some());
-                let ret = (*next).value.take().unwrap();
+                assert!((&(*tail).value).is_none());
+                assert!((&(*next).value).is_some());
+                let ret = (&mut (*next).value).take().unwrap();
                 let _: Box<Node<T>> = Box::from_raw(tail);
                 return Data(ret);
             }
@@ -108,7 +108,7 @@ impl<T> Drop for Queue<T> {
         unsafe {
             let mut cur = *self.tail.get();
             while !cur.is_null() {
-                let next = (*cur).next.load(Ordering::Relaxed);
+                let next = (&(*cur).next).load(Ordering::Relaxed);
                 let _: Box<Node<T>> = Box::from_raw(cur);
                 cur = next;
             }

library/std/src/sync/mpsc/spsc_queue.rs

@@ -102,7 +102,7 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
     ) -> Self {
         let n1 = Node::new();
         let n2 = Node::new();
-        (*n1).next.store(n2, Ordering::Relaxed);
+        (&(*n1).next).store(n2, Ordering::Relaxed);
         Queue {
             consumer: CacheAligned::new(Consumer {
                 tail: UnsafeCell::new(n2),
@@ -127,10 +127,10 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
             // Acquire a node (which either uses a cached one or allocates a new
             // one), and then append this to the 'head' node.
             let n = self.alloc();
-            assert!((*n).value.is_none());
+            assert!((&(*n).value).is_none());
             (*n).value = Some(t);
-            (*n).next.store(ptr::null_mut(), Ordering::Relaxed);
-            (**self.producer.head.get()).next.store(n, Ordering::Release);
+            (&(*n).next).store(ptr::null_mut(), Ordering::Relaxed);
+            (&(**self.producer.head.get()).next).store(n, Ordering::Release);
             *(&self.producer.head).get() = n;
         }
     }
@@ -139,15 +139,15 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
         // First try to see if we can consume the 'first' node for our uses.
         if *self.producer.first.get() != *self.producer.tail_copy.get() {
             let ret = *self.producer.first.get();
-            *self.producer.0.first.get() = (*ret).next.load(Ordering::Relaxed);
+            *self.producer.0.first.get() = (&(*ret).next).load(Ordering::Relaxed);
             return ret;
         }
         // If the above fails, then update our copy of the tail and try
         // again.
         *self.producer.0.tail_copy.get() = self.consumer.tail_prev.load(Ordering::Acquire);
         if *self.producer.first.get() != *self.producer.tail_copy.get() {
             let ret = *self.producer.first.get();
-            *self.producer.0.first.get() = (*ret).next.load(Ordering::Relaxed);
+            *self.producer.0.first.get() = (&(*ret).next).load(Ordering::Relaxed);
             return ret;
         }
         // If all of that fails, then we have to allocate a new node
@@ -164,12 +164,12 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
             // tail's next field and see if we can use it. If we do a pop, then
             // the current tail node is a candidate for going into the cache.
             let tail = *self.consumer.tail.get();
-            let next = (*tail).next.load(Ordering::Acquire);
+            let next = (&(*tail).next).load(Ordering::Acquire);
             if next.is_null() {
                 return None;
             }
-            assert!((*next).value.is_some());
-            let ret = (*next).value.take();
+            assert!((&(*next).value).is_some());
+            let ret = (&mut (*next).value).take();
 
             *self.consumer.0.tail.get() = next;
             if self.consumer.cache_bound == 0 {
@@ -184,8 +184,7 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
                 if (*tail).cached {
                     self.consumer.tail_prev.store(tail, Ordering::Release);
                 } else {
-                    (*self.consumer.tail_prev.load(Ordering::Relaxed))
-                        .next
+                    (&(*self.consumer.tail_prev.load(Ordering::Relaxed)).next)
                         .store(next, Ordering::Relaxed);
                     // We have successfully erased all references to 'tail', so
                     // now we can safely drop it.
@@ -208,8 +207,8 @@ impl<T, ProducerAddition, ConsumerAddition> Queue<T, ProducerAddition, ConsumerA
         // stripped out.
         unsafe {
             let tail = *self.consumer.tail.get();
-            let next = (*tail).next.load(Ordering::Acquire);
-            if next.is_null() { None } else { (*next).value.as_mut() }
+            let next = (&(*tail).next).load(Ordering::Acquire);
+            if next.is_null() { None } else { (&mut (*next).value).as_mut() }
         }
     }
 
@@ -227,7 +226,7 @@ impl<T, ProducerAddition, ConsumerAddition> Drop for Queue<T, ProducerAddition,
         unsafe {
             let mut cur = *self.producer.first.get();
             while !cur.is_null() {
-                let next = (*cur).next.load(Ordering::Relaxed);
+                let next = (&(*cur).next).load(Ordering::Relaxed);
                 let _n: Box<Node<T>> = Box::from_raw(cur);
                 cur = next;
             }

library/std/src/sync/mpsc/sync.rs

@@ -489,7 +489,7 @@ impl Queue {
         }
         unsafe {
             (*node).next = ptr::null_mut();
-            Some((*node).token.take().unwrap())
+            Some((&mut (*node).token).take().unwrap())
         }
     }
 }

library/std/src/thread/local.rs

@@ -1029,8 +1029,8 @@ pub mod fast {
         // causes future calls to `get` to run `try_initialize_drop` again,
         // which will now fail, and return `None`.
         unsafe {
-            let value = (*ptr).inner.take();
-            (*ptr).dtor_state.set(DtorState::RunningOrHasRun);
+            let value = (&mut (*ptr).inner).take();
+            (&(*ptr).dtor_state).set(DtorState::RunningOrHasRun);
             drop(value);
         }
     }