library: use addr_of!

Author: GrigorenkoPV

library/alloc/src/boxed/thin.rs

@@ -176,7 +176,7 @@ impl<T: ?Sized> ThinBox<T> {
 
 fnwith_header(&self) -> &WithHeader<<TasPointee>::Metadata>{
 // SAFETY: both types are transparent to `NonNull<u8>`
-unsafe{&*((&self.ptr)as*constWithOpaqueHeaderas*constWithHeader<_>)}
+unsafe{&*(core::ptr::addr_of!(self.ptr)as*constWithHeader<_>)}
 }
 }
 

library/alloc/src/rc.rs

@@ -1969,7 +1969,7 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
 
 // Copy value as bytes
  ptr::copy_nonoverlapping(
-&*srcas*constTas*constu8,
+core::ptr::addr_of!(*src)as*constu8,
  ptr::addr_of_mut!((*ptr).value)as*mutu8,
  value_size,
 );
@@ -2440,7 +2440,7 @@ impl<T: ?Sized + fmt::Debug, A: Allocator> fmt::Debug for Rc<T, A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized,A:Allocator> fmt::PointerforRc<T,A>{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
- fmt::Pointer::fmt(&(&**selfas*constT), f)
+ fmt::Pointer::fmt(&core::ptr::addr_of!(**self), f)
 }
 }
 

library/alloc/src/sync.rs

@@ -1914,7 +1914,7 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
 
 // Copy value as bytes
  ptr::copy_nonoverlapping(
-&*srcas*constTas*constu8,
+core::ptr::addr_of!(*src)as*constu8,
  ptr::addr_of_mut!((*ptr).data)as*mutu8,
  value_size,
 );
@@ -3265,7 +3265,7 @@ impl<T: ?Sized + fmt::Debug, A: Allocator> fmt::Debug for Arc<T, A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized,A:Allocator> fmt::PointerforArc<T,A>{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
- fmt::Pointer::fmt(&(&**selfas*constT), f)
+ fmt::Pointer::fmt(&core::ptr::addr_of!(**self), f)
 }
 }
 

library/core/src/ffi/c_str.rs

@@ -4,6 +4,7 @@ use crate::ffi::c_char;
 usecrate::fmt;
 usecrate::intrinsics;
 usecrate::ops;
+usecrate::ptr::addr_of;
 usecrate::slice;
 usecrate::slice::memchr;
 usecrate::str;
@@ -603,7 +604,7 @@ impl CStr {
 pubconstfnto_bytes_with_nul(&self) -> &[u8]{
 // SAFETY: Transmuting a slice of `c_char`s to a slice of `u8`s
 // is safe on all supported targets.
-unsafe{&*(&self.inneras*const[c_char]as*const[u8])}
+unsafe{&*(addr_of!(self.inner)as*const[u8])}
 }
 
 /// Yields a <code>&[str]</code> slice if the `CStr` contains valid UTF-8.

library/core/src/iter/adapters/filter_map.rs

@@ -2,6 +2,7 @@ use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable, TrustedF
 usecrate::mem::{ManuallyDrop,MaybeUninit};
 usecrate::num::NonZero;
 usecrate::ops::{ControlFlow,Try};
+usecrate::ptr::addr_of;
 usecrate::{array, fmt};
 
 /// An iterator that uses `f` to both filter and map elements from `iter`.
@@ -98,9 +99,8 @@ where
 // SAFETY: Loop conditions ensure the index is in bounds.
 
 unsafe{
-let opt_payload_at:*constMaybeUninit<B> = (&val as*constOption<B>)
-.byte_add(core::mem::offset_of!(Option<B>,Some.0))
-.cast();
+let opt_payload_at:*constMaybeUninit<B> =
+addr_of!(val).byte_add(core::mem::offset_of!(Option<B>,Some.0)).cast();
 let dst = guard.array.as_mut_ptr().add(idx);
 crate::ptr::copy_nonoverlapping(opt_payload_at, dst,1);
 crate::mem::forget(val);

library/core/src/ptr/mod.rs

@@ -1553,7 +1553,7 @@ pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
 // `dst` cannot overlap `src` because the caller has mutable access
 // to `dst` while `src` is owned by this function.
 unsafe{
-copy_nonoverlapping(&srcas*constTas*constu8, dst as*mutu8, mem::size_of::<T>());
+copy_nonoverlapping(addr_of!(src)as*constu8, dst as*mutu8, mem::size_of::<T>());
 // We are calling the intrinsic directly to avoid function calls in the generated code.
  intrinsics::forget(src);
 }

library/std/src/os/unix/net/addr.rs

@@ -21,7 +21,7 @@ mod libc {
 fnsun_path_offset(addr:&libc::sockaddr_un) -> usize{
 // Work with an actual instance of the type since using a null pointer is UB
 let base = (addr as*const libc::sockaddr_un).addr();
-let path = (&addr.sun_pathas*const libc::c_char).addr();
+let path = core::ptr::addr_of!(addr.sun_path).addr();
  path - base
 }
 
@@ -98,7 +98,7 @@ impl SocketAddr {
 unsafe{
 letmut addr: libc::sockaddr_un = mem::zeroed();
 letmut len = mem::size_of::<libc::sockaddr_un>()as libc::socklen_t;
-cvt(f(&mutaddras*mut_as*mut_,&mut len))?;
+cvt(f(core::ptr::addr_of_mut!(addr)as*mut_,&mut len))?;
 SocketAddr::from_parts(addr, len)
 }
 }

library/std/src/os/unix/net/ancillary.rs

@@ -37,7 +37,7 @@ pub(super) fn recv_vectored_with_ancillary_from(
 unsafe{
 letmut msg_name: libc::sockaddr_un = zeroed();
 letmut msg: libc::msghdr = zeroed();
- msg.msg_name = &mutmsg_nameas*mut_as*mut_;
+ msg.msg_name = core::ptr::addr_of_mut!(msg_name)as*mut_;
  msg.msg_namelen = size_of::<libc::sockaddr_un>()as libc::socklen_t;
  msg.msg_iov = bufs.as_mut_ptr().cast();
  msg.msg_iovlen = bufs.len()as_;
@@ -70,7 +70,7 @@ pub(super) fn send_vectored_with_ancillary_to(
 ifletSome(path) = path {sockaddr_un(path)? }else{(zeroed(),0)};
 
 letmut msg: libc::msghdr = zeroed();
- msg.msg_name = &mutmsg_nameas*mut_as*mut_;
+ msg.msg_name = core::ptr::addr_of_mut!(msg_name)as*mut_;
  msg.msg_namelen = msg_namelen;
  msg.msg_iov = bufs.as_ptr()as*mut_;
  msg.msg_iovlen = bufs.len()as_;

library/std/src/os/unix/net/datagram.rs

@@ -91,7 +91,7 @@ impl UnixDatagram {
 let socket = UnixDatagram::unbound()?;
 let(addr, len) = sockaddr_un(path.as_ref())?;
 
-cvt(libc::bind(socket.as_raw_fd(),&addras*const_as*const_, len as_))?;
+cvt(libc::bind(socket.as_raw_fd(),core::ptr::addr_of!(addr)as*const_, len as_))?;
 
 Ok(socket)
 }
@@ -124,7 +124,7 @@ impl UnixDatagram {
 let socket = UnixDatagram::unbound()?;
 cvt(libc::bind(
  socket.as_raw_fd(),
-&socket_addr.addras*const_as*const_,
+core::ptr::addr_of!(socket_addr.addr)as*const_,
  socket_addr.lenas_,
 ))?;
 Ok(socket)
@@ -206,7 +206,7 @@ impl UnixDatagram {
 unsafe{
 let(addr, len) = sockaddr_un(path.as_ref())?;
 
-cvt(libc::connect(self.as_raw_fd(),&addras*const_as*const_, len))?;
+cvt(libc::connect(self.as_raw_fd(),core::ptr::addr_of!(addr)as*const_, len))?;
 }
 Ok(())
 }
@@ -238,7 +238,7 @@ impl UnixDatagram {
 unsafe{
 cvt(libc::connect(
 self.as_raw_fd(),
-&socket_addr.addras*const_as*const_,
+core::ptr::addr_of!(socket_addr.addr)as*const_,
  socket_addr.len,
 ))?;
 }
@@ -505,7 +505,7 @@ impl UnixDatagram {
  buf.as_ptr()as*const_,
  buf.len(),
 MSG_NOSIGNAL,
-&addras*const_as*const_,
+core::ptr::addr_of!(addr)as*const_,
  len,
 ))?;
 Ok(count asusize)
@@ -540,7 +540,7 @@ impl UnixDatagram {
  buf.as_ptr()as*const_,
  buf.len(),
 MSG_NOSIGNAL,
-&socket_addr.addras*const_as*const_,
+core::ptr::addr_of!(socket_addr.addr)as*const_,
  socket_addr.len,
 ))?;
 Ok(count asusize)

library/std/src/os/unix/net/listener.rs

@@ -99,7 +99,11 @@ impl UnixListener {
 )))]
 const backlog: libc::c_int = libc::SOMAXCONN;
 
-cvt(libc::bind(inner.as_inner().as_raw_fd(),&addr as*const_as*const_, len as_))?;
+cvt(libc::bind(
+ inner.as_inner().as_raw_fd(),
+ core::ptr::addr_of!(addr)as*const_,
+ len as_,
+))?;
 cvt(libc::listen(inner.as_inner().as_raw_fd(), backlog))?;
 
 Ok(UnixListener(inner))
@@ -139,7 +143,7 @@ impl UnixListener {
 const backlog: libc::c_int = 128;
 cvt(libc::bind(
  inner.as_raw_fd(),
-&socket_addr.addras*const_as*const_,
+core::ptr::addr_of!(socket_addr.addr)as*const_,
  socket_addr.lenas_,
 ))?;
 cvt(libc::listen(inner.as_raw_fd(), backlog))?;
@@ -174,7 +178,7 @@ impl UnixListener {
 pubfnaccept(&self) -> io::Result<(UnixStream,SocketAddr)>{
 letmut storage: libc::sockaddr_un = unsafe{ mem::zeroed()};
 letmut len = mem::size_of_val(&storage)as libc::socklen_t;
-let sock = self.0.accept(&mutstorageas*mut_as*mut_,&mut len)?;
+let sock = self.0.accept(core::ptr::addr_of_mut!(storage)as*mut_,&mut len)?;
 let addr = SocketAddr::from_parts(storage, len)?;
 Ok((UnixStream(sock), addr))
 }