Auto merge of #130865 - cuviper:library-raw_ref_op, r=tgross35

Use `&raw` in the standard library
Since the stabilization in #127679 has reached stage0, 1.82-beta, we can
start using `&raw` freely, and even the soft-deprecated `ptr::addr_of!`
and `ptr::addr_of_mut!` can stop allowing the unstable feature.
I intentionally did not change any documentation or tests, but the rest
of those macro uses are all now using `&raw const` or `&raw mut` in the
standard library.

Author: bors

library/alloc/src/boxed.rs

@@ -199,7 +199,7 @@ use core::ops::{
 DerefPure,DispatchFromDyn,Receiver,
 };
 use core::pin::{Pin,PinCoerceUnsized};
-use core::ptr::{self,NonNull,Unique, addr_of_mut};
+use core::ptr::{self,NonNull,Unique};
 use core::task::{Context,Poll};
 use core::{borrow, fmt, slice};
 
@@ -1277,7 +1277,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
 #[inline]
 pubfninto_raw(b:Self) -> *mutT{
 // Make sure Miri realizes that we transition from a noalias pointer to a raw pointer here.
-unsafe{addr_of_mut!(*&mut*Self::into_raw_with_allocator(b).0)}
+unsafe{&rawmut*&mut*Self::into_raw_with_allocator(b).0}
 }
 
 /// Consumes the `Box`, returning a wrapped `NonNull` pointer.
@@ -1396,7 +1396,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
 // want *no* aliasing requirements here!
 // In case `A` *is* `Global`, this does not quite have the right behavior; `into_raw`
 // works around that.
-let ptr = addr_of_mut!(**b);
+let ptr = &rawmut**b;
 let alloc = unsafe{ ptr::read(&b.1)};
 (ptr, alloc)
 }
@@ -1506,7 +1506,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
 pubfnas_mut_ptr(b:&mutSelf) -> *mutT{
 // This is a primitive deref, not going through `DerefMut`, and therefore not materializing
 // any references.
-ptr::addr_of_mut!(**b)
+&rawmut**b
 }
 
 /// Returns a raw pointer to the `Box`'s contents.
@@ -1554,7 +1554,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
 pubfnas_ptr(b:&Self) -> *constT{
 // This is a primitive deref, not going through `DerefMut`, and therefore not materializing
 // any references.
-ptr::addr_of!(**b)
+&rawconst**b
 }
 
 /// Returns a reference to the underlying allocator.

library/alloc/src/boxed/thin.rs

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

library/alloc/src/collections/btree/node.rs

@@ -72,8 +72,8 @@ impl<K, V> LeafNode<K, V> {
 // be both slightly faster and easier to track in Valgrind.
 unsafe{
 // parent_idx, keys, and vals are all MaybeUninit
-ptr::addr_of_mut!((*this).parent).write(None);
-ptr::addr_of_mut!((*this).len).write(0);
+(&rawmut(*this).parent).write(None);
+(&rawmut(*this).len).write(0);
 }
 }
 
@@ -114,7 +114,7 @@ impl<K, V> InternalNode<K, V> {
 unsafe{
 letmut node = Box::<Self,_>::new_uninit_in(alloc);
 // We only need to initialize the data; the edges are MaybeUninit.
-LeafNode::init(ptr::addr_of_mut!((*node.as_mut_ptr()).data));
+LeafNode::init(&rawmut(*node.as_mut_ptr()).data);
  node.assume_init()
 }
 }
@@ -525,8 +525,8 @@ impl<'a, K, V, Type> NodeRef<marker::ValMut<'a>, K, V, Type> {
 // to avoid aliasing with outstanding references to other elements,
 // in particular, those returned to the caller in earlier iterations.
 let leaf = Self::as_leaf_ptr(&mutself);
-let keys = unsafe{ptr::addr_of!((*leaf).keys)};
-let vals = unsafe{ptr::addr_of_mut!((*leaf).vals)};
+let keys = unsafe{&rawconst(*leaf).keys};
+let vals = unsafe{&rawmut(*leaf).vals};
 // We must coerce to unsized array pointers because of Rust issue #74679.
 let keys:*const[_] = keys;
 let vals:*mut[_] = vals;

library/alloc/src/rc.rs

@@ -787,7 +787,7 @@ impl<T, A: Allocator> Rc<T, A> {
 
 let strong = unsafe{
 let inner = init_ptr.as_ptr();
- ptr::write(ptr::addr_of_mut!((*inner).value), data);
+ ptr::write(&rawmut(*inner).value, data);
 
 let prev_value = (*inner).strong.get();
 debug_assert_eq!(prev_value,0,"No prior strong references should exist");
@@ -1442,7 +1442,7 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
 // SAFETY: This cannot go through Deref::deref or Rc::inner because
 // this is required to retain raw/mut provenance such that e.g. `get_mut` can
 // write through the pointer after the Rc is recovered through `from_raw`.
-unsafe{ptr::addr_of_mut!((*ptr).value)}
+unsafe{&rawmut(*ptr).value}
 }
 
 /// Constructs an `Rc<T, A>` from a raw pointer in the provided allocator.
@@ -2042,8 +2042,8 @@ impl<T: ?Sized> Rc<T> {
 unsafe{
 debug_assert_eq!(Layout::for_value_raw(inner), layout);
 
-ptr::addr_of_mut!((*inner).strong).write(Cell::new(1));
-ptr::addr_of_mut!((*inner).weak).write(Cell::new(1));
+(&rawmut(*inner).strong).write(Cell::new(1));
+(&rawmut(*inner).weak).write(Cell::new(1));
 }
 
 Ok(inner)
@@ -2072,8 +2072,8 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
 
 // Copy value as bytes
  ptr::copy_nonoverlapping(
-core::ptr::addr_of!(*src)as*constu8,
-ptr::addr_of_mut!((*ptr).value)as*mutu8,
+(&rawconst*src)as*constu8,
+(&rawmut(*ptr).value)as*mutu8,
  value_size,
 );
 
@@ -2107,11 +2107,7 @@ impl<T> Rc<[T]> {
 unsafefncopy_from_slice(v:&[T]) -> Rc<[T]>{
 unsafe{
 let ptr = Self::allocate_for_slice(v.len());
- ptr::copy_nonoverlapping(
- v.as_ptr(),
- ptr::addr_of_mut!((*ptr).value)as*mutT,
- v.len(),
-);
+ ptr::copy_nonoverlapping(v.as_ptr(),(&rawmut(*ptr).value)as*mutT, v.len());
 Self::from_ptr(ptr)
 }
 }
@@ -2149,7 +2145,7 @@ impl<T> Rc<[T]> {
 let layout = Layout::for_value_raw(ptr);
 
 // Pointer to first element
-let elems = ptr::addr_of_mut!((*ptr).value)as*mutT;
+let elems = (&rawmut(*ptr).value)as*mutT;
 
 letmut guard = Guard{mem:NonNull::new_unchecked(mem), elems, layout,n_elems:0};
 
@@ -2577,7 +2573,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(&core::ptr::addr_of!(**self), f)
+ fmt::Pointer::fmt(&(&rawconst**self), f)
 }
 }
 
@@ -2718,7 +2714,7 @@ impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A> {
 let(vec_ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
 
 let rc_ptr = Self::allocate_for_slice_in(len,&alloc);
- ptr::copy_nonoverlapping(vec_ptr,ptr::addr_of_mut!((*rc_ptr).value)as*mutT, len);
+ ptr::copy_nonoverlapping(vec_ptr,(&rawmut(*rc_ptr).value)as*mutT, len);
 
 // Create a `Vec<T, &A>` with length 0, to deallocate the buffer
 // without dropping its contents or the allocator
@@ -3084,7 +3080,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
 // SAFETY: if is_dangling returns false, then the pointer is dereferenceable.
 // The payload may be dropped at this point, and we have to maintain provenance,
 // so use raw pointer manipulation.
-unsafe{ptr::addr_of_mut!((*ptr).value)}
+unsafe{&rawmut(*ptr).value}
 }
 }
 

library/alloc/src/sync.rs

@@ -797,7 +797,7 @@ impl<T, A: Allocator> Arc<T, A> {
 // reference into a strong reference.
 let strong = unsafe{
 let inner = init_ptr.as_ptr();
- ptr::write(ptr::addr_of_mut!((*inner).data), data);
+ ptr::write(&rawmut(*inner).data, data);
 
 // The above write to the data field must be visible to any threads which
 // observe a non-zero strong count. Therefore we need at least "Release" ordering
@@ -1583,7 +1583,7 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
 // SAFETY: This cannot go through Deref::deref or RcBoxPtr::inner because
 // this is required to retain raw/mut provenance such that e.g. `get_mut` can
 // write through the pointer after the Rc is recovered through `from_raw`.
-unsafe{ptr::addr_of_mut!((*ptr).data)}
+unsafe{&rawmut(*ptr).data}
 }
 
 /// Constructs an `Arc<T, A>` from a raw pointer.
@@ -1955,8 +1955,8 @@ impl<T: ?Sized> Arc<T> {
 debug_assert_eq!(unsafe{Layout::for_value_raw(inner)}, layout);
 
 unsafe{
-ptr::addr_of_mut!((*inner).strong).write(atomic::AtomicUsize::new(1));
-ptr::addr_of_mut!((*inner).weak).write(atomic::AtomicUsize::new(1));
+(&rawmut(*inner).strong).write(atomic::AtomicUsize::new(1));
+(&rawmut(*inner).weak).write(atomic::AtomicUsize::new(1));
 }
 
  inner
@@ -1986,8 +1986,8 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
 
 // Copy value as bytes
  ptr::copy_nonoverlapping(
-core::ptr::addr_of!(*src)as*constu8,
-ptr::addr_of_mut!((*ptr).data)as*mutu8,
+(&rawconst*src)as*constu8,
+(&rawmut(*ptr).data)as*mutu8,
  value_size,
 );
 
@@ -2022,7 +2022,7 @@ impl<T> Arc<[T]> {
 unsafe{
 let ptr = Self::allocate_for_slice(v.len());
 
- ptr::copy_nonoverlapping(v.as_ptr(),ptr::addr_of_mut!((*ptr).data)as*mutT, v.len());
+ ptr::copy_nonoverlapping(v.as_ptr(),(&rawmut(*ptr).data)as*mutT, v.len());
 
 Self::from_ptr(ptr)
 }
@@ -2061,7 +2061,7 @@ impl<T> Arc<[T]> {
 let layout = Layout::for_value_raw(ptr);
 
 // Pointer to first element
-let elems = ptr::addr_of_mut!((*ptr).data)as*mutT;
+let elems = (&rawmut(*ptr).data)as*mutT;
 
 letmut guard = Guard{mem:NonNull::new_unchecked(mem), elems, layout,n_elems:0};
 
@@ -2805,7 +2805,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
 // SAFETY: if is_dangling returns false, then the pointer is dereferenceable.
 // The payload may be dropped at this point, and we have to maintain provenance,
 // so use raw pointer manipulation.
-unsafe{ptr::addr_of_mut!((*ptr).data)}
+unsafe{&rawmut(*ptr).data}
 }
 }
 
@@ -3428,7 +3428,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(&core::ptr::addr_of!(**self), f)
+ fmt::Pointer::fmt(&(&rawconst**self), f)
 }
 }
 
@@ -3678,7 +3678,7 @@ impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A> {
 let(vec_ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
 
 let rc_ptr = Self::allocate_for_slice_in(len,&alloc);
- ptr::copy_nonoverlapping(vec_ptr,ptr::addr_of_mut!((*rc_ptr).data)as*mutT, len);
+ ptr::copy_nonoverlapping(vec_ptr,(&rawmut(*rc_ptr).data)as*mutT, len);
 
 // Create a `Vec<T, &A>` with length 0, to deallocate the buffer
 // without dropping its contents or the allocator

library/alloc/src/vec/into_iter.rs

@@ -21,11 +21,11 @@ use crate::raw_vec::RawVec;
 macro non_null {
 (mut $place:expr, $t:ident) => {{
 #![allow(unused_unsafe)]// we're sometimes used within an unsafe block
-unsafe{&mut*(ptr::addr_of_mut!($place)as*mutNonNull<$t>)}
+unsafe{&mut*((&rawmut$place)as*mutNonNull<$t>)}
 }},
 ($place:expr, $t:ident) => {{
 #![allow(unused_unsafe)]// we're sometimes used within an unsafe block
-unsafe{*(ptr::addr_of!($place)as*constNonNull<$t>)}
+unsafe{*((&rawconst$place)as*constNonNull<$t>)}
 }},
 }
 

library/core/src/ffi/c_str.rs

@@ -5,7 +5,7 @@ use crate::error::Error;
 usecrate::ffi::c_char;
 usecrate::iter::FusedIterator;
 usecrate::marker::PhantomData;
-usecrate::ptr::{NonNull, addr_of};
+usecrate::ptr::NonNull;
 usecrate::slice::memchr;
 usecrate::{fmt, intrinsics, ops, slice, str};
 
@@ -623,7 +623,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{&*(addr_of!(self.inner)as*const[u8])}
+unsafe{&*((&rawconstself.inner)as*const[u8])}
 }
 
 /// Iterates over the bytes in this C string.

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

@@ -3,7 +3,6 @@ use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused};
 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`.
@@ -101,7 +100,7 @@ where
 
 unsafe{
 let opt_payload_at:*constMaybeUninit<B> =
-addr_of!(val).byte_add(core::mem::offset_of!(Option<B>,Some.0)).cast();
+(&rawconstval).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

@@ -1730,7 +1730,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(addr_of!(src)as*constu8, dst as*mutu8, mem::size_of::<T>());
+copy_nonoverlapping((&rawconstsrc)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);
 }
@@ -2348,7 +2348,6 @@ impl<F: FnPtr> fmt::Debug for F {
 /// no difference whether the pointer is null or dangling.)
 #[stable(feature = "raw_ref_macros", since = "1.51.0")]
 #[rustc_macro_transparency = "semitransparent"]
-#[allow_internal_unstable(raw_ref_op)]
 pub macro addr_of($place:expr){
 &rawconst $place
 }
@@ -2439,7 +2438,6 @@ pub macro addr_of($place:expr) {
 /// makes no difference whether the pointer is null or dangling.)
 #[stable(feature = "raw_ref_macros", since = "1.51.0")]
 #[rustc_macro_transparency = "semitransparent"]
-#[allow_internal_unstable(raw_ref_op)]
 pub macro addr_of_mut($place:expr){
 &rawmut $place
 }

library/core/src/slice/iter.rs

@@ -11,7 +11,7 @@ use crate::iter::{
 usecrate::marker::PhantomData;
 usecrate::mem::{self,SizedTypeProperties};
 usecrate::num::NonZero;
-usecrate::ptr::{self,NonNull, without_provenance, without_provenance_mut};
+usecrate::ptr::{NonNull, without_provenance, without_provenance_mut};
 usecrate::{cmp, fmt};
 
 #[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]