try lower msrv

crossbeam-queue/src/array_queue.rs

@@ -6,7 +6,7 @@
 use alloc::boxed::Box;
 use core::cell::UnsafeCell;
 use core::fmt;
-use core::mem::MaybeUninit;
+use core::mem::{ManuallyDrop, MaybeUninit};
 use core::sync::atomic::{self, AtomicUsize, Ordering};
 
 use crossbeam_utils::{Backoff, CachePadded};
@@ -321,7 +321,7 @@ impl<T> ArrayQueue<T> {
         // If the tail and the stamp match, we may push.
         if tail == stamp {
             *self.tail.get_mut() = new_tail;
-            slot.value.get_mut().write(value);
+            unsafe { slot.value.get().write(MaybeUninit::new(value)) }
             *slot.stamp.get_mut() = tail + 1;
             Ok(())
         } else {
@@ -367,7 +367,7 @@ impl<T> ArrayQueue<T> {
     pub fn force_push_sync(&mut self, value: T) -> Option<T> {
         match self.try_push_sync(value) {
             Ok(()) => None,
-            Err((value, new_tail, index)) => {
+            Err((v, new_tail, index)) => {
                 // move the head and tail
                 *self.head.get_mut() = new_tail.wrapping_sub(self.one_lap);
                 let tail = *self.tail.get_mut();
@@ -378,8 +378,7 @@ impl<T> ArrayQueue<T> {
                 let slot = unsafe { self.buffer.get_unchecked_mut(index) };
 
                 // Swap the previous value.
-                let old =
-                    std::mem::replace(unsafe { slot.value.get_mut().assume_init_mut() }, value);
+                let old = unsafe { slot.value.get().replace(MaybeUninit::new(v)).assume_init() };
 
                 // Update the stamp.
                 *slot.stamp.get_mut() = tail + 1;
@@ -494,21 +493,22 @@ impl<T> ArrayQueue<T> {
         if cap > v.len() {
             // reserve_exact to optimise the `into_boxed_slice` call later
             v.reserve_exact(cap - v.len());
-            for (i, slot) in (v.len()..cap).zip(v.spare_capacity_mut()) {
-                slot.write(Slot {
+            let mut stamp = v.len();
+            v.resize_with(cap, || {
+                let i = stamp;
+                stamp += 1;
+                Slot {
                     // Set the stamp to `{ lap: 0, index: i }`.
                     stamp: AtomicUsize::new(i),
                     value: UnsafeCell::new(MaybeUninit::uninit()),
-                });
-            }
-            // Safety: we have just initialised these values
-            unsafe { v.set_len(cap) }
+                }
+            });
         } else {
             if *tail > cap {
                 // drop values
                 unsafe {
                     for slot in v.get_unchecked_mut(cap..*tail) {
-                        slot.value.get_mut().assume_init_drop();
+                        (*slot.value.get()).assume_init_drop();
                     }
                 }
                 *tail = self.one_lap; // tail wraps around
@@ -521,7 +521,8 @@ impl<T> ArrayQueue<T> {
         // we have used `reserve_exact` and `shrink_to_fit` which guarantee to call
         // the allocator with the `cap` we gave it.
         // This means that we are safe to give that memory to a box, because we can dealloc using that same cap
-        let b = unsafe { Box::from_raw(v.leak()) };
+        let ptr = ManuallyDrop::new(v).as_mut_ptr();
+        let b = unsafe { Box::from_raw(std::ptr::slice_from_raw_parts_mut(ptr, cap)) };
 
         // move our new box back into the buffer, leaking the placeholder
         // (LLVM will probably assume it's not-empty)