Skip to content

Commit ff45313

Browse files
cuvipercuviper
committed
Use &raw in the standard library
Since the stabilization in rust-lang#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.
1 parent f50b2ba commit ff45313

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

51 files changed

+150
-185
lines changed

‎alloc/src/boxed.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -199,7 +199,7 @@ use core::ops::{
199199
DerefPure, DispatchFromDyn, Receiver,
200200
};
201201
use core::pin::{Pin, PinCoerceUnsized};
202-
use core::ptr::{self, NonNull, Unique, addr_of_mut};
202+
use core::ptr::{self, NonNull, Unique};
203203
use core::task::{Context, Poll};
204204
use core::{borrow, fmt, slice};
205205

@@ -1277,7 +1277,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
12771277
#[inline]
12781278
pub fn into_raw(b: Self) -> *mut T {
12791279
// Make sure Miri realizes that we transition from a noalias pointer to a raw pointer here.
1280-
unsafe { addr_of_mut!(*&mut *Self::into_raw_with_allocator(b).0) }
1280+
unsafe { &raw mut *&mut *Self::into_raw_with_allocator(b).0 }
12811281
}
12821282

12831283
/// Consumes the `Box`, returning a wrapped `NonNull` pointer.
@@ -1396,7 +1396,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
13961396
// want *no* aliasing requirements here!
13971397
// In case `A` *is* `Global`, this does not quite have the right behavior; `into_raw`
13981398
// works around that.
1399-
let ptr = addr_of_mut!(**b);
1399+
let ptr = &raw mut **b;
14001400
let alloc = unsafe { ptr::read(&b.1) };
14011401
(ptr, alloc)
14021402
}
@@ -1506,7 +1506,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
15061506
pub fn as_mut_ptr(b: &mut Self) -> *mut T {
15071507
// This is a primitive deref, not going through `DerefMut`, and therefore not materializing
15081508
// any references.
1509-
ptr::addr_of_mut!(**b)
1509+
&raw mut **b
15101510
}
15111511

15121512
/// Returns a raw pointer to the `Box`'s contents.
@@ -1554,7 +1554,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
15541554
pub fn as_ptr(b: &Self) -> *const T {
15551555
// This is a primitive deref, not going through `DerefMut`, and therefore not materializing
15561556
// any references.
1557-
ptr::addr_of!(**b)
1557+
&raw const **b
15581558
}
15591559

15601560
/// Returns a reference to the underlying allocator.

‎alloc/src/boxed/thin.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ impl<T: ?Sized> ThinBox<T> {
186186

187187
fn with_header(&self) -> &WithHeader<<T as Pointee>::Metadata> {
188188
// SAFETY: both types are transparent to `NonNull<u8>`
189-
unsafe { &*(core::ptr::addr_of!(self.ptr) as *const WithHeader<_>) }
189+
unsafe { &*((&raw const self.ptr) as *const WithHeader<_>) }
190190
}
191191
}
192192

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

+5-5
Original file line numberDiff line numberDiff line change
@@ -72,8 +72,8 @@ impl<K, V> LeafNode<K, V> {
7272
// be both slightly faster and easier to track in Valgrind.
7373
unsafe {
7474
// parent_idx, keys, and vals are all MaybeUninit
75-
ptr::addr_of_mut!((*this).parent).write(None);
76-
ptr::addr_of_mut!((*this).len).write(0);
75+
(&raw mut (*this).parent).write(None);
76+
(&raw mut (*this).len).write(0);
7777
}
7878
}
7979

@@ -114,7 +114,7 @@ impl<K, V> InternalNode<K, V> {
114114
unsafe {
115115
let mut node = Box::<Self, _>::new_uninit_in(alloc);
116116
// We only need to initialize the data; the edges are MaybeUninit.
117-
LeafNode::init(ptr::addr_of_mut!((*node.as_mut_ptr()).data));
117+
LeafNode::init(&raw mut (*node.as_mut_ptr()).data);
118118
node.assume_init()
119119
}
120120
}
@@ -525,8 +525,8 @@ impl<'a, K, V, Type> NodeRef<marker::ValMut<'a>, K, V, Type> {
525525
// to avoid aliasing with outstanding references to other elements,
526526
// in particular, those returned to the caller in earlier iterations.
527527
let leaf = Self::as_leaf_ptr(&mut self);
528-
let keys = unsafe { ptr::addr_of!((*leaf).keys) };
529-
let vals = unsafe { ptr::addr_of_mut!((*leaf).vals) };
528+
let keys = unsafe { &raw const (*leaf).keys };
529+
let vals = unsafe { &raw mut (*leaf).vals };
530530
// We must coerce to unsized array pointers because of Rust issue #74679.
531531
let keys: *const [_] = keys;
532532
let vals: *mut [_] = vals;

‎alloc/src/rc.rs

+11-15
Original file line numberDiff line numberDiff line change
@@ -787,7 +787,7 @@ impl<T, A: Allocator> Rc<T, A> {
787787

788788
let strong = unsafe {
789789
let inner = init_ptr.as_ptr();
790-
ptr::write(ptr::addr_of_mut!((*inner).value), data);
790+
ptr::write(&raw mut (*inner).value, data);
791791

792792
let prev_value = (*inner).strong.get();
793793
debug_assert_eq!(prev_value, 0, "No prior strong references should exist");
@@ -1442,7 +1442,7 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
14421442
// SAFETY: This cannot go through Deref::deref or Rc::inner because
14431443
// this is required to retain raw/mut provenance such that e.g. `get_mut` can
14441444
// write through the pointer after the Rc is recovered through `from_raw`.
1445-
unsafe { ptr::addr_of_mut!((*ptr).value) }
1445+
unsafe { &raw mut (*ptr).value }
14461446
}
14471447

14481448
/// Constructs an `Rc<T, A>` from a raw pointer in the provided allocator.
@@ -2042,8 +2042,8 @@ impl<T: ?Sized> Rc<T> {
20422042
unsafe {
20432043
debug_assert_eq!(Layout::for_value_raw(inner), layout);
20442044

2045-
ptr::addr_of_mut!((*inner).strong).write(Cell::new(1));
2046-
ptr::addr_of_mut!((*inner).weak).write(Cell::new(1));
2045+
(&raw mut (*inner).strong).write(Cell::new(1));
2046+
(&raw mut (*inner).weak).write(Cell::new(1));
20472047
}
20482048

20492049
Ok(inner)
@@ -2072,8 +2072,8 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
20722072

20732073
// Copy value as bytes
20742074
ptr::copy_nonoverlapping(
2075-
core::ptr::addr_of!(*src) as *const u8,
2076-
ptr::addr_of_mut!((*ptr).value) as *mut u8,
2075+
(&raw const *src) as *const u8,
2076+
(&raw mut (*ptr).value) as *mut u8,
20772077
value_size,
20782078
);
20792079

@@ -2107,11 +2107,7 @@ impl<T> Rc<[T]> {
21072107
unsafe fn copy_from_slice(v: &[T]) -> Rc<[T]> {
21082108
unsafe {
21092109
let ptr = Self::allocate_for_slice(v.len());
2110-
ptr::copy_nonoverlapping(
2111-
v.as_ptr(),
2112-
ptr::addr_of_mut!((*ptr).value) as *mut T,
2113-
v.len(),
2114-
);
2110+
ptr::copy_nonoverlapping(v.as_ptr(), (&raw mut (*ptr).value) as *mut T, v.len());
21152111
Self::from_ptr(ptr)
21162112
}
21172113
}
@@ -2149,7 +2145,7 @@ impl<T> Rc<[T]> {
21492145
let layout = Layout::for_value_raw(ptr);
21502146

21512147
// Pointer to first element
2152-
let elems = ptr::addr_of_mut!((*ptr).value) as *mut T;
2148+
let elems = (&raw mut (*ptr).value) as *mut T;
21532149

21542150
let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 };
21552151

@@ -2577,7 +2573,7 @@ impl<T: ?Sized + fmt::Debug, A: Allocator> fmt::Debug for Rc<T, A> {
25772573
#[stable(feature = "rust1", since = "1.0.0")]
25782574
impl<T: ?Sized, A: Allocator> fmt::Pointer for Rc<T, A> {
25792575
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2580-
fmt::Pointer::fmt(&core::ptr::addr_of!(**self), f)
2576+
fmt::Pointer::fmt(&(&raw const **self), f)
25812577
}
25822578
}
25832579

@@ -2718,7 +2714,7 @@ impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A> {
27182714
let (vec_ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
27192715

27202716
let rc_ptr = Self::allocate_for_slice_in(len, &alloc);
2721-
ptr::copy_nonoverlapping(vec_ptr, ptr::addr_of_mut!((*rc_ptr).value) as *mut T, len);
2717+
ptr::copy_nonoverlapping(vec_ptr, (&raw mut (*rc_ptr).value) as *mut T, len);
27222718

27232719
// Create a `Vec<T, &A>` with length 0, to deallocate the buffer
27242720
// without dropping its contents or the allocator
@@ -3084,7 +3080,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
30843080
// SAFETY: if is_dangling returns false, then the pointer is dereferenceable.
30853081
// The payload may be dropped at this point, and we have to maintain provenance,
30863082
// so use raw pointer manipulation.
3087-
unsafe { ptr::addr_of_mut!((*ptr).value) }
3083+
unsafe { &raw mut (*ptr).value }
30883084
}
30893085
}
30903086

‎alloc/src/sync.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -797,7 +797,7 @@ impl<T, A: Allocator> Arc<T, A> {
797797
// reference into a strong reference.
798798
let strong = unsafe {
799799
let inner = init_ptr.as_ptr();
800-
ptr::write(ptr::addr_of_mut!((*inner).data), data);
800+
ptr::write(&raw mut (*inner).data, data);
801801

802802
// The above write to the data field must be visible to any threads which
803803
// 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> {
15831583
// SAFETY: This cannot go through Deref::deref or RcBoxPtr::inner because
15841584
// this is required to retain raw/mut provenance such that e.g. `get_mut` can
15851585
// write through the pointer after the Rc is recovered through `from_raw`.
1586-
unsafe { ptr::addr_of_mut!((*ptr).data) }
1586+
unsafe { &raw mut (*ptr).data }
15871587
}
15881588

15891589
/// Constructs an `Arc<T, A>` from a raw pointer.
@@ -1955,8 +1955,8 @@ impl<T: ?Sized> Arc<T> {
19551955
debug_assert_eq!(unsafe { Layout::for_value_raw(inner) }, layout);
19561956

19571957
unsafe {
1958-
ptr::addr_of_mut!((*inner).strong).write(atomic::AtomicUsize::new(1));
1959-
ptr::addr_of_mut!((*inner).weak).write(atomic::AtomicUsize::new(1));
1958+
(&raw mut (*inner).strong).write(atomic::AtomicUsize::new(1));
1959+
(&raw mut (*inner).weak).write(atomic::AtomicUsize::new(1));
19601960
}
19611961

19621962
inner
@@ -1986,8 +1986,8 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
19861986

19871987
// Copy value as bytes
19881988
ptr::copy_nonoverlapping(
1989-
core::ptr::addr_of!(*src) as *const u8,
1990-
ptr::addr_of_mut!((*ptr).data) as *mut u8,
1989+
(&raw const *src) as *const u8,
1990+
(&raw mut (*ptr).data) as *mut u8,
19911991
value_size,
19921992
);
19931993

@@ -2022,7 +2022,7 @@ impl<T> Arc<[T]> {
20222022
unsafe {
20232023
let ptr = Self::allocate_for_slice(v.len());
20242024

2025-
ptr::copy_nonoverlapping(v.as_ptr(), ptr::addr_of_mut!((*ptr).data) as *mut T, v.len());
2025+
ptr::copy_nonoverlapping(v.as_ptr(), (&raw mut (*ptr).data) as *mut T, v.len());
20262026

20272027
Self::from_ptr(ptr)
20282028
}
@@ -2061,7 +2061,7 @@ impl<T> Arc<[T]> {
20612061
let layout = Layout::for_value_raw(ptr);
20622062

20632063
// Pointer to first element
2064-
let elems = ptr::addr_of_mut!((*ptr).data) as *mut T;
2064+
let elems = (&raw mut (*ptr).data) as *mut T;
20652065

20662066
let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 };
20672067

@@ -2805,7 +2805,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
28052805
// SAFETY: if is_dangling returns false, then the pointer is dereferenceable.
28062806
// The payload may be dropped at this point, and we have to maintain provenance,
28072807
// so use raw pointer manipulation.
2808-
unsafe { ptr::addr_of_mut!((*ptr).data) }
2808+
unsafe { &raw mut (*ptr).data }
28092809
}
28102810
}
28112811

@@ -3428,7 +3428,7 @@ impl<T: ?Sized + fmt::Debug, A: Allocator> fmt::Debug for Arc<T, A> {
34283428
#[stable(feature = "rust1", since = "1.0.0")]
34293429
impl<T: ?Sized, A: Allocator> fmt::Pointer for Arc<T, A> {
34303430
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3431-
fmt::Pointer::fmt(&core::ptr::addr_of!(**self), f)
3431+
fmt::Pointer::fmt(&(&raw const **self), f)
34323432
}
34333433
}
34343434

@@ -3678,7 +3678,7 @@ impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A> {
36783678
let (vec_ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
36793679

36803680
let rc_ptr = Self::allocate_for_slice_in(len, &alloc);
3681-
ptr::copy_nonoverlapping(vec_ptr, ptr::addr_of_mut!((*rc_ptr).data) as *mut T, len);
3681+
ptr::copy_nonoverlapping(vec_ptr, (&raw mut (*rc_ptr).data) as *mut T, len);
36823682

36833683
// Create a `Vec<T, &A>` with length 0, to deallocate the buffer
36843684
// without dropping its contents or the allocator

‎alloc/src/vec/into_iter.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -21,11 +21,11 @@ use crate::raw_vec::RawVec;
2121
macro non_null {
2222
(mut $place:expr, $t:ident) => {{
2323
#![allow(unused_unsafe)] // we're sometimes used within an unsafe block
24-
unsafe { &mut *(ptr::addr_of_mut!($place) as *mut NonNull<$t>) }
24+
unsafe { &mut *((&raw mut $place) as *mut NonNull<$t>) }
2525
}},
2626
($place:expr, $t:ident) => {{
2727
#![allow(unused_unsafe)] // we're sometimes used within an unsafe block
28-
unsafe { *(ptr::addr_of!($place) as *const NonNull<$t>) }
28+
unsafe { *((&raw const $place) as *const NonNull<$t>) }
2929
}},
3030
}
3131

‎core/src/ffi/c_str.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use crate::error::Error;
55
use crate::ffi::c_char;
66
use crate::iter::FusedIterator;
77
use crate::marker::PhantomData;
8-
use crate::ptr::{NonNull, addr_of};
8+
use crate::ptr::NonNull;
99
use crate::slice::memchr;
1010
use crate::{fmt, intrinsics, ops, slice, str};
1111

@@ -623,7 +623,7 @@ impl CStr {
623623
pub const fn to_bytes_with_nul(&self) -> &[u8] {
624624
// SAFETY: Transmuting a slice of `c_char`s to a slice of `u8`s
625625
// is safe on all supported targets.
626-
unsafe { &*(addr_of!(self.inner) as *const [u8]) }
626+
unsafe { &*((&raw const self.inner) as *const [u8]) }
627627
}
628628

629629
/// Iterates over the bytes in this C string.

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

+1-2
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@ use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused};
33
use crate::mem::{ManuallyDrop, MaybeUninit};
44
use crate::num::NonZero;
55
use crate::ops::{ControlFlow, Try};
6-
use crate::ptr::addr_of;
76
use crate::{array, fmt};
87

98
/// An iterator that uses `f` to both filter and map elements from `iter`.
@@ -101,7 +100,7 @@ where
101100

102101
unsafe {
103102
let opt_payload_at: *const MaybeUninit<B> =
104-
addr_of!(val).byte_add(core::mem::offset_of!(Option<B>, Some.0)).cast();
103+
(&raw const val).byte_add(core::mem::offset_of!(Option<B>, Some.0)).cast();
105104
let dst = guard.array.as_mut_ptr().add(idx);
106105
crate::ptr::copy_nonoverlapping(opt_payload_at, dst, 1);
107106
crate::mem::forget(val);

‎core/src/ptr/mod.rs

+1-3
Original file line numberDiff line numberDiff line change
@@ -1730,7 +1730,7 @@ pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
17301730
// `dst` cannot overlap `src` because the caller has mutable access
17311731
// to `dst` while `src` is owned by this function.
17321732
unsafe {
1733-
copy_nonoverlapping(addr_of!(src) as *const u8, dst as *mut u8, mem::size_of::<T>());
1733+
copy_nonoverlapping((&raw const src) as *const u8, dst as *mut u8, mem::size_of::<T>());
17341734
// We are calling the intrinsic directly to avoid function calls in the generated code.
17351735
intrinsics::forget(src);
17361736
}
@@ -2348,7 +2348,6 @@ impl<F: FnPtr> fmt::Debug for F {
23482348
/// no difference whether the pointer is null or dangling.)
23492349
#[stable(feature = "raw_ref_macros", since = "1.51.0")]
23502350
#[rustc_macro_transparency = "semitransparent"]
2351-
#[allow_internal_unstable(raw_ref_op)]
23522351
pub macro addr_of($place:expr) {
23532352
&raw const $place
23542353
}
@@ -2439,7 +2438,6 @@ pub macro addr_of($place:expr) {
24392438
/// makes no difference whether the pointer is null or dangling.)
24402439
#[stable(feature = "raw_ref_macros", since = "1.51.0")]
24412440
#[rustc_macro_transparency = "semitransparent"]
2442-
#[allow_internal_unstable(raw_ref_op)]
24432441
pub macro addr_of_mut($place:expr) {
24442442
&raw mut $place
24452443
}

‎core/src/slice/iter.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ use crate::iter::{
1111
use crate::marker::PhantomData;
1212
use crate::mem::{self, SizedTypeProperties};
1313
use crate::num::NonZero;
14-
use crate::ptr::{self, NonNull, without_provenance, without_provenance_mut};
14+
use crate::ptr::{NonNull, without_provenance, without_provenance_mut};
1515
use crate::{cmp, fmt};
1616

1717
#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]

‎core/src/slice/iter/macros.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -14,11 +14,11 @@ macro_rules! if_zst {
1414
if T::IS_ZST {
1515
// SAFETY: for ZSTs, the pointer is storing a provenance-free length,
1616
// so consuming and updating it as a `usize` is fine.
17-
let $len = unsafe { &mut *ptr::addr_of_mut!($this.end_or_len).cast::<usize>() };
17+
let $len = unsafe { &mut *(&raw mut $this.end_or_len).cast::<usize>() };
1818
$zst_body
1919
} else {
2020
// SAFETY: for non-ZSTs, the type invariant ensures it cannot be null
21-
let $end = unsafe { &mut *ptr::addr_of_mut!($this.end_or_len).cast::<NonNull<T>>() };
21+
let $end = unsafe { &mut *(&raw mut $this.end_or_len).cast::<NonNull<T>>() };
2222
$other_body
2323
}
2424
}};
@@ -30,7 +30,7 @@ macro_rules! if_zst {
3030
$zst_body
3131
} else {
3232
// SAFETY: for non-ZSTs, the type invariant ensures it cannot be null
33-
let $end = unsafe { *ptr::addr_of!($this.end_or_len).cast::<NonNull<T>>() };
33+
let $end = unsafe { *(&raw const $this.end_or_len).cast::<NonNull<T>>() };
3434
$other_body
3535
}
3636
}};

‎core/src/slice/mod.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -883,8 +883,8 @@ impl<T> [T] {
883883
pub const fn swap(&mut self, a: usize, b: usize) {
884884
// FIXME: use swap_unchecked here (https://github.com/rust-lang/rust/pull/88540#issuecomment-944344343)
885885
// Can't take two mutable loans from one vector, so instead use raw pointers.
886-
let pa = ptr::addr_of_mut!(self[a]);
887-
let pb = ptr::addr_of_mut!(self[b]);
886+
let pa = &raw mut self[a];
887+
let pb = &raw mut self[b];
888888
// SAFETY: `pa` and `pb` have been created from safe mutable references and refer
889889
// to elements in the slice and therefore are guaranteed to be valid and aligned.
890890
// Note that accessing the elements behind `a` and `b` is checked and will

‎panic_unwind/src/emcc.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -78,7 +78,7 @@ pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
7878
super::__rust_foreign_exception();
7979
}
8080

81-
let canary = ptr::addr_of!((*adjusted_ptr).canary).read();
81+
let canary = (&raw const (*adjusted_ptr).canary).read();
8282
if !ptr::eq(canary, &EXCEPTION_TYPE_INFO) {
8383
super::__rust_foreign_exception();
8484
}

‎panic_unwind/src/gcc.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
9292
let exception = exception.cast::<Exception>();
9393
// Just access the canary field, avoid accessing the entire `Exception` as
9494
// it can be a foreign Rust exception.
95-
let canary = ptr::addr_of!((*exception).canary).read();
95+
let canary = (&raw const (*exception).canary).read();
9696
if !ptr::eq(canary, &CANARY) {
9797
// A foreign Rust exception, treat it slightly differently from other
9898
// foreign exceptions, because call into `_Unwind_DeleteException` will

0 commit comments

Comments
 (0)