diff --git a/crates/edit/src/base64.rs b/crates/edit/src/base64.rs index 4df68f46e0a..b659a1f5405 100644 --- a/crates/edit/src/base64.rs +++ b/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::().read_unaligned()); inp = inp.add(3); remaining -= 3; diff --git a/crates/edit/src/hash.rs b/crates/edit/src/hash.rs index 84bc4f04499..d06837cb420 100644 --- a/crates/edit/src/hash.rs +++ b/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::().read_unaligned() as u64 } } unsafe fn wyr8(p: *const u8) -> u64 { - unsafe { (p as *const u64).read_unaligned() } + unsafe { p.cast::().read_unaligned() } } // This is a weak mix function on its own. It may be worth considering diff --git a/crates/edit/src/helpers.rs b/crates/edit/src/helpers.rs index f8539f8155f..bddc7266ba3 100644 --- a/crates/edit/src/helpers.rs +++ b/crates/edit/src/helpers.rs @@ -149,7 +149,7 @@ impl Rect { /// [`Read`] but with [`MaybeUninit`] buffers. pub fn file_read_uninit(file: &mut T, buf: &mut [MaybeUninit]) -> io::Result { 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::(), buf.len()); let n = file.read(buf_slice)?; Ok(n) } diff --git a/crates/edit/src/icu.rs b/crates/edit/src/icu.rs index 67578aaffe6..1461761353d 100644 --- a/crates/edit/src/icu.rs +++ b/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::(); 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::(); 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::(); 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( @@ -853,9 +853,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, ) @@ -869,9 +869,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, ) @@ -936,7 +936,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() }; } @@ -1011,7 +1012,7 @@ fn init_if_needed() -> Result<&'static LibraryFunctions> { ); let mut funcs = MaybeUninit::::uninit(); - let mut ptr = funcs.as_mut_ptr() as *mut TransparentFunction; + let mut ptr = funcs.as_mut_ptr().cast::(); #[cfg(edit_icu_renaming_auto_detect)] let scratch_outer = scratch_arena(None); diff --git a/crates/edit/src/simd/memchr2.rs b/crates/edit/src/simd/memchr2.rs index 0514da05c4c..dc5c61a369b 100644 --- a/crates/edit/src/simd/memchr2.rs +++ b/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); diff --git a/crates/edit/src/sys/unix.rs b/crates/edit/src/sys/unix.rs index 552eb4eaed6..be4cc1cbdad 100644 --- a/crates/edit/src/sys/unix.rs +++ b/crates/edit/src/sys/unix.rs @@ -225,7 +225,7 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option 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 { 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 }) } } diff --git a/crates/stdext/src/arena/fs.rs b/crates/stdext/src/arena/fs.rs index c67d9dd876f..72037493a15 100644 --- a/crates/stdext/src/arena/fs.rs +++ b/crates/stdext/src/arena/fs.rs @@ -52,7 +52,7 @@ pub fn read_to_string>(arena: &Arena, path: P) -> io::Result(file: &mut T, buf: &mut [MaybeUninit]) -> io::Result { 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) } diff --git a/crates/stdext/src/arena/release.rs b/crates/stdext/src/arena/release.rs index 747356658c2..c39e712d39b 100644 --- a/crates/stdext/src/arena/release.rs +++ b/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 { diff --git a/crates/stdext/src/collections/vec.rs b/crates/stdext/src/collections/vec.rs index 1bddaa4b611..1c8c8abc629 100644 --- a/crates/stdext/src/collections/vec.rs +++ b/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 { - unsafe { (self.ptr.as_ptr() as *mut MaybeUninit).add(self.len) } + unsafe { self.ptr.as_ptr().cast::>().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); } } diff --git a/crates/stdext/src/helpers.rs b/crates/stdext/src/helpers.rs index 8619dac5b35..8396cfcf918 100644 --- a/crates/stdext/src/helpers.rs +++ b/crates/stdext/src/helpers.rs @@ -142,13 +142,13 @@ fn vec_replace_impl(dst: &mut Vec, range: Range, src: &[T]) { /// Turns a [`&[u8]`] into a [`&[MaybeUninit]`]. #[inline(always)] pub const fn slice_as_uninit_ref(slice: &[T]) -> &[MaybeUninit] { - unsafe { slice::from_raw_parts(slice.as_ptr() as *const MaybeUninit, slice.len()) } + unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) } } /// Turns a [`&mut [T]`] into a [`&mut [MaybeUninit]`]. #[inline(always)] pub const fn slice_as_uninit_mut(slice: &mut [T]) -> &mut [MaybeUninit] { - unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit, 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`). diff --git a/crates/stdext/src/simd/memset.rs b/crates/stdext/src/simd/memset.rs index ab2adf564ae..15d921220f3 100644 --- a/crates/stdext/src/simd/memset.rs +++ b/crates/stdext/src/simd/memset.rs @@ -31,19 +31,19 @@ pub fn memset(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); } _ => dst.fill(val), } @@ -68,19 +68,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::().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::().write_unaligned(val as u32); + end.sub(4).cast::().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::().write_unaligned(val as u16); + end.sub(2).cast::().write_unaligned(val as u16); } else if remaining >= 1 { // 1 byte remaining beg.write(val as u8); @@ -348,8 +348,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; @@ -362,20 +362,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::().write_unaligned(val); + end.sub(8).cast::().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::().write_unaligned(val as u32); + end.sub(4).cast::().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::().write_unaligned(val as u16); + end.sub(2).cast::().write_unaligned(val as u16); } else if remaining >= 1 { // 1 byte remaining beg.write(val as u8); diff --git a/crates/stdext/src/sys/unix.rs b/crates/stdext/src/sys/unix.rs index 2d0575b1dc5..50f57463f5e 100644 --- a/crates/stdext/src/sys/unix.rs +++ b/crates/stdext/src/sys/unix.rs @@ -26,7 +26,7 @@ pub unsafe fn virtual_reserve(size: usize) -> io::Result> { if ptr.is_null() || ptr::eq(ptr, libc::MAP_FAILED) { Err(io::Error::last_os_error()) } else { - Ok(NonNull::new_unchecked(ptr as *mut u8)) + Ok(NonNull::new_unchecked(ptr.cast())) } } }