clippy: fix ptr_as_ptr lint (#730)

Author: xtqqczze

crates/edit/src/base64.rs

@@ -36,7 +36,7 @@ pub fn encode<'a>(arena: &'a Arena, dst: &mut BString<'a>, 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

@@ -149,7 +149,7 @@ impl Rect {
 /// [`Read`] but with [`MaybeUninit<u8>`] buffers.
 pub fn file_read_uninit<T: Read>(file: &mut T, buf: &mut [MaybeUninit<u8>]) -> io::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)
     }

crates/edit/src/icu.rs

@@ -103,7 +103,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() {
@@ -182,7 +182,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 })
@@ -217,11 +217,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();
@@ -359,7 +359,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(
@@ -874,9 +874,9 @@ pub fn fold_case<'a>(arena: &'a Arena, input: &str) -> BString<'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,
                 )
@@ -890,9 +890,9 @@ pub fn fold_case<'a>(arena: &'a Arena, input: &str) -> BString<'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,
                 )
@@ -958,7 +958,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()
     };
 }
 
@@ -1034,7 +1035,7 @@ fn init_if_needed() -> 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/sys/unix.rs

@@ -225,7 +225,7 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option<BString<
 
             // 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;
@@ -305,7 +305,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;
@@ -417,11 +417,11 @@ pub fn load_icu() -> io::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/arena/fs.rs

@@ -52,7 +52,7 @@ pub fn read_to_string<P: AsRef<Path>>(arena: &Arena, path: P) -> io::Result<BStr
 
 fn file_read_uninit<T: Read>(file: &mut T, buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
     unsafe {
-        let buf_slice = from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len());
+        let buf_slice = from_raw_parts_mut(buf.as_mut_ptr().cast(), buf.len());
         let n = file.read(buf_slice)?;
         Ok(n)
     }

crates/stdext/src/arena/release.rs

@@ -228,7 +228,7 @@ impl Allocator for Arena {
             // Otherwise, we have to allocate a new area and copy it over.
             unsafe {
                 let new_ptr = self.alloc_raw(new_size, align);
-                ptr::copy_nonoverlapping(old_ptr.as_ptr(), new_ptr.as_ptr() as *mut _, old_size);
+                ptr::copy_nonoverlapping(old_ptr.as_ptr(), new_ptr.as_ptr().cast(), old_size);
                 new_ptr
             }
         } else {

crates/stdext/src/collections/vec.rs

@@ -149,7 +149,7 @@ impl<'a, T> BVec<'a, T> {
 
     #[inline]
     fn spare_mut_ptr(&mut self) -> *mut MaybeUninit<T> {
-        unsafe { (self.ptr.as_ptr() as *mut MaybeUninit<T>).add(self.len) }
+        unsafe { self.ptr.as_ptr().cast::<MaybeUninit<T>>().add(self.len) }
     }
 
     /// View as a shared slice.
@@ -342,7 +342,7 @@ impl<'a, T: Copy> BVec<'a, T> {
         unsafe {
             let dst = self.spare_mut_ptr();
             self.len += add;
-            ptr::copy_nonoverlapping(other.as_ptr() as *const _, dst, add);
+            ptr::copy_nonoverlapping(other.as_ptr().cast(), dst, add);
         }
     }
 

crates/stdext/src/helpers.rs

@@ -142,13 +142,13 @@ fn vec_replace_impl<T: Copy>(dst: &mut Vec<T>, range: Range<usize>, src: &[T]) {
 /// 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()) }
 }
 
 /// A stable clone of [`String::from_utf8_lossy_owned`] (`string_from_utf8_lossy_owned`).