clippy: fix ptr_as_ptr lint

https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr

Author: xtqqczze

crates/edit/src/base64.rs

@@ -35,7 +35,7 @@ pub fn encode(dst: &mut ArenaString, src: &[u8]) {
                 // SAFETY: Thanks to `remaining > 3`, reading 4 bytes at once is safe.
                 // This improves performance massively over a byte-by-byte approach,
                 // because it allows us to byte-swap the read and use simple bit-shifts below.
-                let val = u32::from_be((inp as *const u32).read_unaligned());
+                let val = u32::from_be(inp.cast::<u32>().read_unaligned());
                 inp = inp.add(3);
                 remaining -= 3;
 

crates/edit/src/hash.rs

@@ -91,11 +91,11 @@ unsafe fn wyr3(p: *const u8, k: usize) -> u64 {
 }
 
 unsafe fn wyr4(p: *const u8) -> u64 {
-    unsafe { (p as *const u32).read_unaligned() as u64 }
+    unsafe { p.cast::<u32>().read_unaligned() as u64 }
 }
 
 unsafe fn wyr8(p: *const u8) -> u64 {
-    unsafe { (p as *const u64).read_unaligned() }
+    unsafe { p.cast::<u64>().read_unaligned() }
 }
 
 // This is a weak mix function on its own. It may be worth considering

crates/edit/src/helpers.rs

@@ -255,7 +255,7 @@ pub fn file_read_uninit<T: Read>(
     buf: &mut [MaybeUninit<u8>],
 ) -> apperr::Result<usize> {
     unsafe {
-        let buf_slice = slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len());
+        let buf_slice = slice::from_raw_parts_mut(buf.as_mut_ptr().cast::<u8>(), buf.len());
         let n = file.read(buf_slice)?;
         Ok(n)
     }
@@ -264,13 +264,13 @@ pub fn file_read_uninit<T: Read>(
 /// Turns a [`&[u8]`] into a [`&[MaybeUninit<T>]`].
 #[inline(always)]
 pub const fn slice_as_uninit_ref<T>(slice: &[T]) -> &[MaybeUninit<T>] {
-    unsafe { slice::from_raw_parts(slice.as_ptr() as *const MaybeUninit<T>, slice.len()) }
+    unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) }
 }
 
 /// Turns a [`&mut [T]`] into a [`&mut [MaybeUninit<T>]`].
 #[inline(always)]
 pub const fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {
-    unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit<T>, slice.len()) }
+    unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len()) }
 }
 
 /// Helpers for ASCII string comparisons.

crates/edit/src/icu.rs

@@ -65,7 +65,7 @@ pub fn get_available_encodings() -> &'static Encodings {
                     let mut status = icu_ffi::U_ZERO_ERROR;
                     let mime = (f.ucnv_getStandardName)(
                         name.as_ptr(),
-                        c"MIME".as_ptr() as *const _,
+                        c"MIME".as_ptr().cast(),
                         &mut status,
                     );
                     if !mime.is_null() && status.is_success() {
@@ -169,7 +169,7 @@ impl<'pivot> Converter<'pivot> {
             return Err(status.as_error());
         }
 
-        let pivot_source = pivot_buffer.as_mut_ptr() as *mut u16;
+        let pivot_source = pivot_buffer.as_mut_ptr().cast::<u16>();
         let pivot_target = unsafe { pivot_source.add(pivot_buffer.len()) };
 
         Ok(Self { source, target, pivot_buffer, pivot_source, pivot_target, reset: true })
@@ -204,11 +204,11 @@ impl<'pivot> Converter<'pivot> {
         let input_end = unsafe { input_beg.add(input.len()) };
         let mut input_ptr = input_beg;
 
-        let output_beg = output.as_mut_ptr() as *mut u8;
+        let output_beg = output.as_mut_ptr().cast::<u8>();
         let output_end = unsafe { output_beg.add(output.len()) };
         let mut output_ptr = output_beg;
 
-        let pivot_beg = self.pivot_buffer.as_mut_ptr() as *mut u16;
+        let pivot_beg = self.pivot_buffer.as_mut_ptr().cast::<u16>();
         let pivot_end = unsafe { pivot_beg.add(self.pivot_buffer.len()) };
 
         let flush = input.is_empty();
@@ -346,7 +346,7 @@ fn text_buffer_from_utext<'a>(ut: &icu_ffi::UText) -> &'a TextBuffer {
 }
 
 fn double_cache_from_utext<'a>(ut: &icu_ffi::UText) -> &'a mut DoubleCache {
-    unsafe { &mut *(ut.p_extra as *mut DoubleCache) }
+    unsafe { &mut *ut.p_extra.cast() }
 }
 
 extern "C" fn utext_clone(
@@ -844,9 +844,9 @@ pub fn fold_case<'a>(arena: &'a Arena, input: &str) -> ArenaString<'a> {
             output_len = unsafe {
                 (f.ucasemap_utf8FoldCase)(
                     casemap,
-                    output.as_mut_ptr() as *mut _,
+                    output.as_mut_ptr().cast(),
                     output.len() as i32,
-                    input.as_ptr() as *const _,
+                    input.as_ptr().cast(),
                     input.len() as i32,
                     &mut status,
                 )
@@ -860,9 +860,9 @@ pub fn fold_case<'a>(arena: &'a Arena, input: &str) -> ArenaString<'a> {
             output_len = unsafe {
                 (f.ucasemap_utf8FoldCase)(
                     casemap,
-                    output.as_mut_ptr() as *mut _,
+                    output.as_mut_ptr().cast(),
                     output.len() as i32,
-                    input.as_ptr() as *const _,
+                    input.as_ptr().cast(),
                     input.len() as i32,
                     &mut status,
                 )
@@ -927,7 +927,8 @@ struct LibraryFunctions {
 macro_rules! proc_name {
     ($s:literal) => {
         concat!(env!("EDIT_CFG_ICU_EXPORT_PREFIX"), $s, env!("EDIT_CFG_ICU_EXPORT_SUFFIX"), "\0")
-            .as_ptr() as *const c_char
+            .as_ptr()
+            .cast()
     };
 }
 
@@ -1002,7 +1003,7 @@ fn init_if_needed() -> apperr::Result<&'static LibraryFunctions> {
             );
 
             let mut funcs = MaybeUninit::<LibraryFunctions>::uninit();
-            let mut ptr = funcs.as_mut_ptr() as *mut TransparentFunction;
+            let mut ptr = funcs.as_mut_ptr().cast::<TransparentFunction>();
 
             #[cfg(edit_icu_renaming_auto_detect)]
             let scratch_outer = scratch_arena(None);

crates/edit/src/simd/memchr2.rs

@@ -195,7 +195,7 @@ unsafe fn memchr2_neon(needle1: u8, needle2: u8, mut beg: *const u8, end: *const
             let n2 = vdupq_n_u8(needle2);
 
             loop {
-                let v = vld1q_u8(beg as *const _);
+                let v = vld1q_u8(beg.cast());
                 let a = vceqq_u8(v, n1);
                 let b = vceqq_u8(v, n2);
                 let c = vorrq_u8(a, b);

crates/edit/src/simd/memset.rs

@@ -51,19 +51,19 @@ pub fn memset<T: MemsetSafe>(dst: &mut [T], val: T) {
                 let beg = dst.as_mut_ptr();
                 let end = beg.add(dst.len());
                 let val = mem::transmute_copy::<_, u16>(&val);
-                memset_raw(beg as *mut u8, end as *mut u8, val as u64 * 0x0001000100010001);
+                memset_raw(beg.cast(), end.cast(), val as u64 * 0x0001000100010001);
             }
             4 => {
                 let beg = dst.as_mut_ptr();
                 let end = beg.add(dst.len());
                 let val = mem::transmute_copy::<_, u32>(&val);
-                memset_raw(beg as *mut u8, end as *mut u8, val as u64 * 0x0000000100000001);
+                memset_raw(beg.cast(), end.cast(), val as u64 * 0x0000000100000001);
             }
             8 => {
                 let beg = dst.as_mut_ptr();
                 let end = beg.add(dst.len());
                 let val = mem::transmute_copy::<_, u64>(&val);
-                memset_raw(beg as *mut u8, end as *mut u8, val);
+                memset_raw(beg.cast(), end.cast(), val);
             }
             _ => unreachable!(),
         }
@@ -88,19 +88,19 @@ unsafe fn memset_fallback(mut beg: *mut u8, end: *mut u8, val: u64) {
         let mut remaining = end.offset_from_unsigned(beg);
 
         while remaining >= 8 {
-            (beg as *mut u64).write_unaligned(val);
+            beg.cast::<u64>().write_unaligned(val);
             beg = beg.add(8);
             remaining -= 8;
         }
 
         if remaining >= 4 {
             // 4-7 bytes remaining
-            (beg as *mut u32).write_unaligned(val as u32);
-            (end.sub(4) as *mut u32).write_unaligned(val as u32);
+            beg.cast::<u32>().write_unaligned(val as u32);
+            end.sub(4).cast::<u32>().write_unaligned(val as u32);
         } else if remaining >= 2 {
             // 2-3 bytes remaining
-            (beg as *mut u16).write_unaligned(val as u16);
-            (end.sub(2) as *mut u16).write_unaligned(val as u16);
+            beg.cast::<u16>().write_unaligned(val as u16);
+            end.sub(2).cast::<u16>().write_unaligned(val as u16);
         } else if remaining >= 1 {
             // 1 byte remaining
             beg.write(val as u8);
@@ -368,8 +368,8 @@ unsafe fn memset_neon(mut beg: *mut u8, end: *mut u8, val: u64) {
 
             loop {
                 // Compiles to a single `stp` instruction.
-                vst1q_u64(beg as *mut _, fill);
-                vst1q_u64(beg.add(16) as *mut _, fill);
+                vst1q_u64(beg.cast(), fill);
+                vst1q_u64(beg.add(16).cast(), fill);
 
                 beg = beg.add(32);
                 remaining -= 32;
@@ -382,20 +382,20 @@ unsafe fn memset_neon(mut beg: *mut u8, end: *mut u8, val: u64) {
         if remaining >= 16 {
             // 16-31 bytes remaining
             let fill = vdupq_n_u64(val);
-            vst1q_u64(beg as *mut _, fill);
-            vst1q_u64(end.sub(16) as *mut _, fill);
+            vst1q_u64(beg.cast(), fill);
+            vst1q_u64(end.sub(16).cast(), fill);
         } else if remaining >= 8 {
             // 8-15 bytes remaining
-            (beg as *mut u64).write_unaligned(val);
-            (end.sub(8) as *mut u64).write_unaligned(val);
+            beg.cast::<u64>().write_unaligned(val);
+            end.sub(8).cast::<u64>().write_unaligned(val);
         } else if remaining >= 4 {
             // 4-7 bytes remaining
-            (beg as *mut u32).write_unaligned(val as u32);
-            (end.sub(4) as *mut u32).write_unaligned(val as u32);
+            beg.cast::<u32>().write_unaligned(val as u32);
+            end.sub(4).cast::<u32>().write_unaligned(val as u32);
         } else if remaining >= 2 {
             // 2-3 bytes remaining
-            (beg as *mut u16).write_unaligned(val as u16);
-            (end.sub(2) as *mut u16).write_unaligned(val as u16);
+            beg.cast::<u16>().write_unaligned(val as u16);
+            end.sub(2).cast::<u16>().write_unaligned(val as u16);
         } else if remaining >= 1 {
             // 1 byte remaining
             beg.write(val as u8);

crates/edit/src/sys/unix.rs

@@ -225,7 +225,7 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option<ArenaStr
 
             // Read from stdin.
             let spare = buf.spare_capacity_mut();
-            let ret = libc::read(STATE.stdin, spare.as_mut_ptr() as *mut _, spare.len());
+            let ret = libc::read(STATE.stdin, spare.as_mut_ptr().cast(), spare.len());
             if ret > 0 {
                 buf.set_len(buf.len() + ret as usize);
                 break;
@@ -306,7 +306,7 @@ pub fn write_stdout(text: &str) {
     while written < buf.len() {
         let w = &buf[written..];
         let w = &buf[..w.len().min(GIBI)];
-        let n = unsafe { libc::write(STATE.stdout, w.as_ptr() as *const _, w.len()) };
+        let n = unsafe { libc::write(STATE.stdout, w.as_ptr().cast(), w.len()) };
 
         if n >= 0 {
             written += n as usize;
@@ -421,11 +421,11 @@ pub fn load_icu() -> apperr::Result<LibIcu> {
     const LIBICUI18N: &str = concat!(env!("EDIT_CFG_ICUI18N_SONAME"), "\0");
 
     if const { const_str_eq(LIBICUUC, LIBICUI18N) } {
-        let icu = unsafe { load_library(LIBICUUC.as_ptr() as *const _)? };
+        let icu = unsafe { load_library(LIBICUUC.as_ptr().cast())? };
         Ok(LibIcu { libicuuc: icu, libicui18n: icu })
     } else {
-        let libicuuc = unsafe { load_library(LIBICUUC.as_ptr() as *const _)? };
-        let libicui18n = unsafe { load_library(LIBICUI18N.as_ptr() as *const _)? };
+        let libicuuc = unsafe { load_library(LIBICUUC.as_ptr().cast())? };
+        let libicui18n = unsafe { load_library(LIBICUI18N.as_ptr().cast())? };
         Ok(LibIcu { libicuuc, libicui18n })
     }
 }

crates/stdext/src/helpers.rs

@@ -142,13 +142,13 @@ fn vec_replace_impl<T: Copy, A: Allocator>(dst: &mut Vec<T, A>, range: Range<usi
 /// Turns a [`&[u8]`] into a [`&[MaybeUninit<T>]`].
 #[inline(always)]
 pub const fn slice_as_uninit_ref<T>(slice: &[T]) -> &[MaybeUninit<T>] {
-    unsafe { slice::from_raw_parts(slice.as_ptr() as *const MaybeUninit<T>, slice.len()) }
+    unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) }
 }
 
 /// Turns a [`&mut [T]`] into a [`&mut [MaybeUninit<T>]`].
 #[inline(always)]
 pub const fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {
-    unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit<T>, slice.len()) }
+    unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len()) }
 }
 
 /// Helpers for ASCII string comparisons.

crates/stdext/src/sys/unix.rs

@@ -26,7 +26,7 @@ pub unsafe fn virtual_reserve(size: usize) -> Result<NonNull<u8>, AllocError> {
         if ptr.is_null() || ptr::eq(ptr, libc::MAP_FAILED) {
             Err(AllocError)
         } else {
-            Ok(NonNull::new_unchecked(ptr as *mut u8))
+            Ok(NonNull::new_unchecked(ptr.cast()))
         }
     }
 }