Favor .cast() over as

rust-lang/rust-clippy#8017

Author: taiki-e

crossbeam-channel/src/flavors/array.rs

@@ -216,7 +216,7 @@ impl<T> Channel<T> {
             return Err(msg);
         }
 
-        let slot: &Slot<T> = &*(token.array.slot as *const Slot<T>);
+        let slot: &Slot<T> = &*token.array.slot.cast::<Slot<T>>();
 
         // Write the message into the slot and update the stamp.
         slot.msg.get().write(MaybeUninit::new(msg));
@@ -307,7 +307,7 @@ impl<T> Channel<T> {
             return Err(());
         }
 
-        let slot: &Slot<T> = &*(token.array.slot as *const Slot<T>);
+        let slot: &Slot<T> = &*token.array.slot.cast::<Slot<T>>();
 
         // Read the message from the slot and update the stamp.
         let msg = slot.msg.get().read().assume_init();

crossbeam-channel/src/flavors/list.rs

@@ -285,7 +285,7 @@ impl<T> Channel<T> {
         }
 
         // Write the message into the slot.
-        let block = token.list.block as *mut Block<T>;
+        let block = token.list.block.cast::<Block<T>>();
         let offset = token.list.offset;
         let slot = (*block).slots.get_unchecked(offset);
         slot.msg.get().write(MaybeUninit::new(msg));

crossbeam-channel/src/flavors/zero.rs

@@ -190,7 +190,7 @@ impl<T> Channel<T> {
             // heap-allocated packet.
             packet.wait_ready();
             let msg = packet.msg.get().replace(None).unwrap();
-            drop(Box::from_raw(token.zero.0 as *mut Packet<T>));
+            drop(Box::from_raw(token.zero.0.cast::<Packet<T>>()));
             Ok(msg)
         }
     }
@@ -409,15 +409,15 @@ impl<T> SelectHandle for Receiver<'_, T> {
         let mut inner = self.0.inner.lock().unwrap();
         inner
             .receivers
-            .register_with_packet(oper, packet as *mut (), cx);
+            .register_with_packet(oper, packet.cast::<()>(), cx);
         inner.senders.notify();
         inner.senders.can_select() || inner.is_disconnected
     }
 
     fn unregister(&self, oper: Operation) {
         if let Some(operation) = self.0.inner.lock().unwrap().receivers.unregister(oper) {
             unsafe {
-                drop(Box::from_raw(operation.packet as *mut Packet<T>));
+                drop(Box::from_raw(operation.packet.cast::<Packet<T>>()));
             }
         }
     }
@@ -459,15 +459,15 @@ impl<T> SelectHandle for Sender<'_, T> {
         let mut inner = self.0.inner.lock().unwrap();
         inner
             .senders
-            .register_with_packet(oper, packet as *mut (), cx);
+            .register_with_packet(oper, packet.cast::<()>(), cx);
         inner.receivers.notify();
         inner.receivers.can_select() || inner.is_disconnected
     }
 
     fn unregister(&self, oper: Operation) {
         if let Some(operation) = self.0.inner.lock().unwrap().senders.unregister(oper) {
             unsafe {
-                drop(Box::from_raw(operation.packet as *mut Packet<T>));
+                drop(Box::from_raw(operation.packet.cast::<Packet<T>>()));
             }
         }
     }

crossbeam-deque/src/deque.rs

@@ -64,7 +64,7 @@ impl<T> Buffer<T> {
     /// that would be more expensive and difficult to implement generically for all types `T`.
     /// Hence, as a hack, we use a volatile write instead.
     unsafe fn write(&self, index: isize, task: MaybeUninit<T>) {
-        ptr::write_volatile(self.at(index) as *mut MaybeUninit<T>, task)
+        ptr::write_volatile(self.at(index).cast::<MaybeUninit<T>>(), task)
     }
 
     /// Reads a task from the specified `index`.
@@ -74,7 +74,7 @@ impl<T> Buffer<T> {
     /// that would be more expensive and difficult to implement generically for all types `T`.
     /// Hence, as a hack, we use a volatile load instead.
     unsafe fn read(&self, index: isize) -> MaybeUninit<T> {
-        ptr::read_volatile(self.at(index) as *mut MaybeUninit<T>)
+        ptr::read_volatile(self.at(index).cast::<MaybeUninit<T>>())
     }
 }
 

crossbeam-epoch/src/atomic.rs

@@ -252,7 +252,7 @@ impl<T> Pointable for [MaybeUninit<T>] {
         let size = mem::size_of::<Array<T>>() + mem::size_of::<MaybeUninit<T>>() * len;
         let align = mem::align_of::<Array<T>>();
         let layout = alloc::Layout::from_size_align(size, align).unwrap();
-        let ptr = alloc::alloc(layout) as *mut Array<T>;
+        let ptr = alloc::alloc(layout).cast::<Array<T>>();
         if ptr.is_null() {
             alloc::handle_alloc_error(layout);
         }

crossbeam-epoch/src/deferred.rs

@@ -46,10 +46,10 @@ impl Deferred {
         unsafe {
             if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() {
                 let mut data = MaybeUninit::<Data>::uninit();
-                ptr::write(data.as_mut_ptr() as *mut F, f);
+                ptr::write(data.as_mut_ptr().cast::<F>(), f);
 
                 unsafe fn call<F: FnOnce()>(raw: *mut u8) {
-                    let f: F = ptr::read(raw as *mut F);
+                    let f: F = ptr::read(raw.cast::<F>());
                     f();
                 }
 
@@ -61,12 +61,12 @@ impl Deferred {
             } else {
                 let b: Box<F> = Box::new(f);
                 let mut data = MaybeUninit::<Data>::uninit();
-                ptr::write(data.as_mut_ptr() as *mut Box<F>, b);
+                ptr::write(data.as_mut_ptr().cast::<Box<F>>(), b);
 
                 unsafe fn call<F: FnOnce()>(raw: *mut u8) {
                     // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is
                     // originally derived from `*mut Box<F>`.
-                    let b: Box<F> = ptr::read(raw as *mut Box<F>);
+                    let b: Box<F> = ptr::read(raw.cast::<Box<F>>());
                     (*b)();
                 }
 
@@ -83,7 +83,7 @@ impl Deferred {
     #[inline]
     pub(crate) fn call(mut self) {
         let call = self.call;
-        unsafe { call(self.data.as_mut_ptr() as *mut u8) };
+        unsafe { call(self.data.as_mut_ptr().cast::<u8>()) };
     }
 }
 

crossbeam-skiplist/src/base.rs

@@ -99,7 +99,7 @@ impl<K, V> Node<K, V> {
     /// why this function is unsafe.
     unsafe fn alloc(height: usize, ref_count: usize) -> *mut Self {
         let layout = Self::get_layout(height);
-        let ptr = alloc(layout) as *mut Self;
+        let ptr = alloc(layout).cast::<Self>();
         if ptr.is_null() {
             handle_alloc_error(layout);
         }
@@ -118,7 +118,7 @@ impl<K, V> Node<K, V> {
     unsafe fn dealloc(ptr: *mut Self) {
         let height = (*ptr).height();
         let layout = Self::get_layout(height);
-        dealloc(ptr as *mut u8, layout);
+        dealloc(ptr.cast::<u8>(), layout);
     }
 
     /// Returns the layout of a node with the given `height`.

crossbeam-utils/src/atomic/atomic_cell.rs

@@ -180,7 +180,7 @@ impl<T> AtomicCell<T> {
     /// ```
     #[inline]
     pub fn as_ptr(&self) -> *mut T {
-        self.value.get() as *mut T
+        self.value.get().cast::<T>()
     }
 }
 
@@ -1005,7 +1005,7 @@ where
                 // do atomic reads and atomic writes, but we can't atomically read and write all
                 // kinds of data since `AtomicU8` is not available on stable Rust yet.
                 // Load as `MaybeUninit` because we may load a value that is not valid as `T`.
-                let val = ptr::read_volatile(src as *mut MaybeUninit<T>);
+                let val = ptr::read_volatile(src.cast::<MaybeUninit<T>>());
 
                 if lock.validate_read(stamp) {
                     return val.assume_init();

crossbeam-utils/src/sync/parker.rs

@@ -264,7 +264,7 @@ impl Unparker {
     /// # let _ = unsafe { Unparker::from_raw(raw) };
     /// ```
     pub fn into_raw(this: Unparker) -> *const () {
-        Arc::into_raw(this.inner) as *const ()
+        Arc::into_raw(this.inner).cast::<()>()
     }
 
     /// Converts a raw pointer into an `Unparker`.
@@ -286,7 +286,7 @@ impl Unparker {
     /// ```
     pub unsafe fn from_raw(ptr: *const ()) -> Unparker {
         Unparker {
-            inner: Arc::from_raw(ptr as *const Inner),
+            inner: Arc::from_raw(ptr.cast::<Inner>()),
         }
     }
 }