Remove many as-casts of pointers

Author: GrigorenkoPV

crates/line-tables-only/src/lib.rs

@@ -13,7 +13,7 @@ mod tests {
 
     extern "C" fn store_backtrace(data: *mut c_void) {
         let bt = backtrace::Backtrace::new();
-        unsafe { *(data as *mut Option<Backtrace>) = Some(bt) };
+        unsafe { *data.cast::<Option<Backtrace>>() = Some(bt) };
     }
 
     fn assert_contains(
@@ -50,7 +50,7 @@ mod tests {
     #[cfg_attr(windows, ignore)]
     fn backtrace_works_with_line_tables_only() {
         let mut backtrace: Option<Backtrace> = None;
-        unsafe { foo(store_backtrace, addr_of_mut!(backtrace) as *mut c_void) };
+        unsafe { foo(store_backtrace, addr_of_mut!(backtrace).cast::<c_void>()) };
         let backtrace = backtrace.expect("backtrace");
         assert_contains(&backtrace, "foo", "src/callback.c", 13);
         assert_contains(&backtrace, "bar", "src/callback.c", 9);

src/backtrace/dbghelp.rs

@@ -141,7 +141,7 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
 
         let frame = super::Frame {
             inner: Frame {
-                base_address: fn_entry as *mut c_void,
+                base_address: fn_entry.cast::<c_void>(),
                 ip: context.ip() as *mut c_void,
                 sp: context.sp() as *mut c_void,
                 #[cfg(not(target_env = "gnu"))]
@@ -162,7 +162,7 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
             context.ip(),
             fn_entry,
             &mut context.0,
-            ptr::addr_of_mut!(handler_data) as *mut PVOID,
+            ptr::addr_of_mut!(handler_data).cast::<PVOID>(),
             &mut establisher_frame,
             ptr::null_mut(),
         );

src/backtrace/libunwind.rs

@@ -102,13 +102,13 @@ impl Clone for Frame {
 
 #[inline(always)]
 pub unsafe fn trace(mut cb: &mut dyn FnMut(&super::Frame) -> bool) {
-    uw::_Unwind_Backtrace(trace_fn, addr_of_mut!(cb) as *mut _);
+    uw::_Unwind_Backtrace(trace_fn, addr_of_mut!(cb).cast());
 
     extern "C" fn trace_fn(
         ctx: *mut uw::_Unwind_Context,
         arg: *mut c_void,
     ) -> uw::_Unwind_Reason_Code {
-        let cb = unsafe { &mut *(arg as *mut &mut dyn FnMut(&super::Frame) -> bool) };
+        let cb = unsafe { &mut *arg.cast::<&mut dyn FnMut(&super::Frame) -> bool>() };
         let cx = super::Frame {
             inner: Frame::Raw(ctx),
         };
@@ -251,7 +251,7 @@ mod uw {
                     _Unwind_VRS_RegClass::_UVRSC_CORE,
                     15,
                     _Unwind_VRS_DataRepresentation::_UVRSD_UINT32,
-                    ptr as *mut c_void,
+                    ptr.cast::<c_void>(),
                 );
                 (val & !1) as libc::uintptr_t
             }
@@ -267,7 +267,7 @@ mod uw {
                     _Unwind_VRS_RegClass::_UVRSC_CORE,
                     SP,
                     _Unwind_VRS_DataRepresentation::_UVRSD_UINT32,
-                    ptr as *mut c_void,
+                    ptr.cast::<c_void>(),
                 );
                 val as libc::uintptr_t
             }

src/backtrace/miri.rs

@@ -65,15 +65,20 @@ pub fn trace<F: FnMut(&super::Frame) -> bool>(cb: F) {
 pub fn resolve_addr(ptr: *mut c_void) -> Frame {
     // SAFETY: Miri will stop execution with an error if this pointer
     // is invalid.
-    let frame = unsafe { miri_resolve_frame(ptr as *mut (), 1) };
+    let frame = unsafe { miri_resolve_frame(ptr.cast::<()>(), 1) };
 
     let mut name = Vec::with_capacity(frame.name_len);
     let mut filename = Vec::with_capacity(frame.filename_len);
 
     // SAFETY: name and filename have been allocated with the amount
     // of memory miri has asked for, and miri guarantees it will initialize it
     unsafe {
-        miri_resolve_frame_names(ptr as *mut (), 0, name.as_mut_ptr(), filename.as_mut_ptr());
+        miri_resolve_frame_names(
+            ptr.cast::<()>(),
+            0,
+            name.as_mut_ptr(),
+            filename.as_mut_ptr(),
+        );
 
         name.set_len(frame.name_len);
         filename.set_len(frame.filename_len);
@@ -101,7 +106,7 @@ unsafe fn trace_unsynchronized<F: FnMut(&super::Frame) -> bool>(mut cb: F) {
     frames.set_len(len);
 
     for ptr in frames.iter() {
-        let frame = resolve_addr(*ptr as *mut c_void);
+        let frame = resolve_addr((*ptr).cast::<c_void>());
         if !cb(&super::Frame { inner: frame }) {
             return;
         }

src/backtrace/noop.rs

@@ -2,6 +2,7 @@
 //! appropriate.
 
 use core::ffi::c_void;
+use core::ptr::null_mut;
 
 #[inline(always)]
 pub fn trace(_cb: &mut dyn FnMut(&super::Frame) -> bool) {}
@@ -11,15 +12,15 @@ pub struct Frame;
 
 impl Frame {
     pub fn ip(&self) -> *mut c_void {
-        0 as *mut _
+        null_mut()
     }
 
     pub fn sp(&self) -> *mut c_void {
-        0 as *mut _
+        null_mut()
     }
 
     pub fn symbol_address(&self) -> *mut c_void {
-        0 as *mut _
+        null_mut()
     }
 
     pub fn module_base_address(&self) -> Option<*mut c_void> {

src/capture.rs

@@ -272,7 +272,7 @@ impl BacktraceFrame {
     /// This function requires the `std` feature of the `backtrace` crate to be
     /// enabled, and the `std` feature is enabled by default.
     pub fn ip(&self) -> *mut c_void {
-        self.frame.ip() as *mut c_void
+        self.frame.ip()
     }
 
     /// Same as `Frame::symbol_address`
@@ -282,7 +282,7 @@ impl BacktraceFrame {
     /// This function requires the `std` feature of the `backtrace` crate to be
     /// enabled, and the `std` feature is enabled by default.
     pub fn symbol_address(&self) -> *mut c_void {
-        self.frame.symbol_address() as *mut c_void
+        self.frame.symbol_address()
     }
 
     /// Same as `Frame::module_base_address`
@@ -292,9 +292,7 @@ impl BacktraceFrame {
     /// This function requires the `std` feature of the `backtrace` crate to be
     /// enabled, and the `std` feature is enabled by default.
     pub fn module_base_address(&self) -> Option<*mut c_void> {
-        self.frame
-            .module_base_address()
-            .map(|addr| addr as *mut c_void)
+        self.frame.module_base_address()
     }
 
     /// Returns the list of symbols that this frame corresponds to.

src/dbghelp.rs

@@ -88,7 +88,7 @@ macro_rules! dbghelp {
 
         static mut DBGHELP: Dbghelp = Dbghelp {
             // Initially we haven't loaded the DLL
-            dll: 0 as *mut _,
+            dll: ptr::null_mut(),
             // Initially all functions are set to zero to say they need to be
             // dynamically loaded.
             $($name: 0,)*
@@ -108,7 +108,7 @@ macro_rules! dbghelp {
                 }
                 let lib = b"dbghelp.dll\0";
                 unsafe {
-                    self.dll = LoadLibraryA(lib.as_ptr() as *const i8);
+                    self.dll = LoadLibraryA(lib.as_ptr().cast::<i8>());
                     if self.dll.is_null() {
                         Err(())
                     }  else {
@@ -135,7 +135,7 @@ macro_rules! dbghelp {
 
             fn symbol(&self, symbol: &[u8]) -> Option<usize> {
                 unsafe {
-                    match GetProcAddress(self.dll, symbol.as_ptr() as *const _) as usize {
+                    match GetProcAddress(self.dll, symbol.as_ptr().cast()) as usize {
                         0 => None,
                         n => Some(n),
                     }

src/lib.rs

@@ -159,11 +159,12 @@ impl Drop for Bomb {
 mod lock {
     use std::boxed::Box;
     use std::cell::Cell;
+    use std::ptr;
     use std::sync::{Mutex, MutexGuard, Once};
 
     pub struct LockGuard(Option<MutexGuard<'static, ()>>);
 
-    static mut LOCK: *mut Mutex<()> = 0 as *mut _;
+    static mut LOCK: *mut Mutex<()> = ptr::null_mut();
     static INIT: Once = Once::new();
     thread_local!(static LOCK_HELD: Cell<bool> = Cell::new(false));
 

src/print/fuchsia.rs

@@ -359,7 +359,7 @@ fn for_each_dso(mut visitor: &mut DsoPrinter<'_, '_>) {
         // location.
         let name_len = unsafe { libc::strlen(info.name) };
         let name_slice: &[u8] =
-            unsafe { core::slice::from_raw_parts(info.name as *const u8, name_len) };
+            unsafe { core::slice::from_raw_parts(info.name.cast::<u8>(), name_len) };
         let name = match core::str::from_utf8(name_slice) {
             Ok(name) => name,
             Err(_) => {

src/symbolize/dbghelp.rs

@@ -23,6 +23,7 @@ use core::char;
 use core::ffi::c_void;
 use core::marker;
 use core::mem;
+use core::ptr;
 use core::slice;
 
 // Store an OsString on std so we can provide the symbol name and filename.
@@ -44,7 +45,7 @@ impl Symbol<'_> {
     }
 
     pub fn addr(&self) -> Option<*mut c_void> {
-        Some(self.addr as *mut _)
+        Some(self.addr)
     }
 
     pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
@@ -184,8 +185,7 @@ unsafe fn do_resolve(
 ) {
     const SIZE: usize = 2 * MAX_SYM_NAME + mem::size_of::<SYMBOL_INFOW>();
     let mut data = Aligned8([0u8; SIZE]);
-    let data = &mut data.0;
-    let info = &mut *(data.as_mut_ptr() as *mut SYMBOL_INFOW);
+    let info = &mut *data.0.as_mut_ptr().cast::<SYMBOL_INFOW>();
     info.MaxNameLen = MAX_SYM_NAME as ULONG;
     // the struct size in C.  the value is different to
     // `size_of::<SYMBOL_INFOW>() - MAX_SYM_NAME + 1` (== 81)
@@ -200,7 +200,7 @@ unsafe fn do_resolve(
     // give a buffer of (MaxNameLen - 1) characters and set NameLen to
     // the real value.
     let name_len = ::core::cmp::min(info.NameLen as usize, info.MaxNameLen as usize - 1);
-    let name_ptr = info.Name.as_ptr() as *const u16;
+    let name_ptr = info.Name.as_ptr().cast::<u16>();
     let name = slice::from_raw_parts(name_ptr, name_len);
 
     // Reencode the utf-16 symbol to utf-8 so we can use `SymbolName::new` like
@@ -222,7 +222,7 @@ unsafe fn do_resolve(
             }
         }
     }
-    let name = core::ptr::addr_of!(name_buffer[..name_len]);
+    let name = ptr::addr_of!(name_buffer[..name_len]);
 
     let mut line = mem::zeroed::<IMAGEHLP_LINEW64>();
     line.SizeOfStruct = mem::size_of::<IMAGEHLP_LINEW64>() as DWORD;
@@ -240,7 +240,7 @@ unsafe fn do_resolve(
 
         let len = len as usize;
 
-        filename = Some(slice::from_raw_parts(base, len) as *const [u16]);
+        filename = Some(ptr::from_ref(slice::from_raw_parts(base, len)));
     }
 
     cb(&super::Symbol {