Tracking Issue for const_ptr_write

[usbalbin]

Feature gate: #![feature(const_ptr_write)]

This is a tracking issue for making the functions ptr::write and ptr::write_unaligned, and the same methods on *mut T, const fn.

Public API

mod ptr {
    pub const unsafe fn write<T>(dst: *mut T, src: T);
    pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T);
    pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
}

impl<T> *mut T {
    pub const unsafe fn write(self, val: T);
    pub const unsafe fn write_unaligned(self, val: T);
    pub const unsafe fn write_bytes(self, val: u8, count: usize);
}

impl <T> NonNull<T> {
    pub const unsafe fn write(self, val: T);
    pub const unsafe fn write_unaligned(self, val: T);
    pub const unsafe fn write_bytes(self, val: u8, count: usize);
}

Steps / History

• Implementation: Make ptr::write const #81167
• Reverted: Make copy/copy_nonoverlapping fn's again #86003
• Re-constified: Revert revert of constness in #86003 #86295
• core::intrinsics::write_bytes aka ptr::write_bytes - Make intrinsics::write_bytes const #90081
• (*mut T)::write_bytes - Make (*mut T)::write_bytes const #91824
• blocked on Tracking issue for &mut T in const contexts (const_mut_refs) #57349
• NonNull methods stabilized, constness moved to this gate Stabilize non_null_convenience #124498
• Final commenting period (FCP)
• Stabilization PR

Related

• const_ptr_read Tracking Issue for const_ptr_read #80377

Unresolved Questions

• None yet.

[lilasta]

core::intrinsics::write_bytes and (*mut T)::write_bytes have been constified: #90081 #91824

[SUPERCILEX]

How does one initiate the FCP? Or are there any blockers?

[c410-f3r]

AFAICT, there are no blockers so this feature can probably be stabilized.

[RalfJung]

How does stabilizing this help? You can't create mutable pointers in const on stable anyway...

[RalfJung]

IOW, this is blocked on #57349 getting stabilized first.

[wyfo]

How does stabilizing this help? You can't create mutable pointers in const on stable anyway...

It seems you can with UnsafeCell::raw_get.

[RalfJung]

Oh fun, another accidental stabilization...

Well, #57349 should be stable soon, so it's not worth de-stabilizing like we did with #80697.

[RalfJung]

@rust-lang/libs-api with #129195 in FCP, I'd like to get the ball rolling for stabilizing this feature as well, so that it can be released together with const_mut_refs. After all, what good is a mutable raw pointer if you cannot .write() it? Okay, you can use *ptr = ...;, and in const context we don't allow Drop types, so this can't cause destructor problems... but still, these functions seem like basic functionality to go with "you can have mutable pointers and references now", so would be nice to ship them all in one package.

So, can we get a t-libs-api FCP started for this? :)

[dtolnay]

@rfcbot fcp merge

const for these 6 already-stable functions, in the same order as shown at the top of this issue:

• https://doc.rust-lang.org/nightly/std/ptr/fn.write.html
• https://doc.rust-lang.org/nightly/std/ptr/fn.write_unaligned.html
• https://doc.rust-lang.org/nightly/std/ptr/fn.write_bytes.html
• https://doc.rust-lang.org/nightly/std/primitive.pointer.html#method.write
• https://doc.rust-lang.org/nightly/std/primitive.pointer.html#method.write_unaligned
• https://doc.rust-lang.org/nightly/std/primitive.pointer.html#method.write_bytes

[rfcbot]

Team member @dtolnay has proposed to merge this. The next step is review by the rest of the tagged team members:

• @Amanieu
• @BurntSushi
• @dtolnay
• @joshtriplett
• @m-ou-se

No concerns currently listed.

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

See this document for info about what commands tagged team members can give me.

[RalfJung]

@Amanieu @BurntSushi @joshtriplett @m-ou-se this proposes to stabilize some very basic *mut T operations that would be nice to ship together with the const_mut_refs stabilization. Given that these have been stable outside const since forever, it should be entirely uncontroversial. :)

[RalfJung]

FYI, turns out there are three more functions under this feature gate -- NonNull has the exact same set of functions as *mut.

impl <T> NonNull<T> {
    pub const unsafe fn write(self, val: T);
    pub const unsafe fn write_unaligned(self, val: T);
    pub const unsafe fn write_bytes(self, val: u8, count: usize);
}

[rfcbot]

🔔 This is now entering its final comment period, as per the review above. 🔔

[rfcbot]

The final comment period, with a disposition to merge, as per the review above, is now complete.

As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.

This will be merged soon.