https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=1.76.0 2023-12-05T19:52:41+00:00 2023-12-05T19:52:41+00:00 Michael Goulet michael@errs.io 2023-12-05T19:52:41+00:00 urn:sha1:19bf7495605962df2b0bfa96382a4f717f63b0c3 Add support for making lib features internal We have the notion of an "internal" lang feature: a feature that is never intended to be stabilized, and using which can cause ICEs and other issues without that being considered a bug. This extends that idea to lib features as well. It is an alternative to https://github.com/rust-lang/rust/pull/115623: instead of using an attribute to declare lib features internal, we simply do this based on the name. Everything ending in `_internals` or `_internal` is considered internal. Then we rename `core_intrinsics` to `core_intrinsics_internal`, which fixes https://github.com/rust-lang/rust/issues/115597. 2023-11-28T12:22:16+00:00 bors bors@rust-lang.org 2023-11-28T12:22:16+00:00 urn:sha1:df0295f07175acc7325ce3ca4152eb05752af1f2 Expand in-place iteration specialization to Flatten, FlatMap and ArrayChunks This enables the following cases to collect in-place: ```rust let v = vec![[0u8; 4]; 1024] let v: Vec<_> = v.into_iter().flatten().collect(); let v: Vec<Option<NonZeroUsize>> = vec![NonZeroUsize::new(0); 1024]; let v: Vec<_> = v.into_iter().flatten().collect(); let v = vec![u8; 4096]; let v: Vec<_> = v.into_iter().array_chunks::<4>().collect(); ``` Especially the nicheful-option-flattening should be useful in real code. 2023-11-22T19:00:56+00:00 Ralf Jung post@ralfj.de 2023-11-22T06:30:09+00:00 urn:sha1:74834a9d74ce2a26bf0ee609ce2790299226f742 2023-11-03T00:35:20+00:00 ltdk usr@ltdk.xyz 2023-10-13T06:44:19+00:00 urn:sha1:8337e86b28b9cdab7250e39710a1c81b99aeeb8d 2023-09-03T17:59:47+00:00 The 8472 git@infinite-source.de 2023-04-15T10:59:16+00:00 urn:sha1:3ca6bb0b44c3e65dab07e12aec9efb277dc206f9 2023-06-14T07:28:54+00:00 The 8472 git@infinite-source.de 2023-04-08T22:37:21+00:00 urn:sha1:114d5f221c135e3267fbb966e2f0e582361cd8cb 2023-04-16T11:38:52+00:00 Deadbeef ent3rm4n@gmail.com 2023-04-16T11:12:37+00:00 urn:sha1:4c6ddc036b13cc9fa06e437295476231a7c11435 2023-04-02T07:04:01+00:00 bors bors@rust-lang.org 2023-04-02T07:04:01+00:00 urn:sha1:637d7fdb2333dcd8eadaec2eb95273e7569c46cc Stabilize `binary_heap_retain` FCP finished in tracking issue: #71503 2023-03-30T10:12:23+00:00 bors bors@rust-lang.org 2023-03-30T10:12:23+00:00 urn:sha1:8a7ca936e61d04399198911ee2b07ac110bf17b0 Partial stabilization of `once_cell` This PR aims to stabilize a portion of the `once_cell` feature: - `core::cell::OnceCell` - `std::cell::OnceCell` (re-export of the above) - `std::sync::OnceLock` This will leave `LazyCell` and `LazyLock` unstabilized, which have been moved to the `lazy_cell` feature flag. Tracking issue: https://github.com/rust-lang/rust/issues/74465 (does not fully close, but it may make sense to move to a new issue) Future steps for separate PRs: - ~~Add `#[inline]` to many methods~~ #105651 - Update cranelift usage of the `once_cell` crate - Update rust-analyzer usage of the `once_cell` crate - Update error messages discussing once_cell ## To be stabilized API summary ```rust // core::cell (in core/cell/once.rs) pub struct OnceCell<T> { .. } impl<T> OnceCell<T> { pub const fn new() -> OnceCell<T>; pub fn get(&self) -> Option<&T>; pub fn get_mut(&mut self) -> Option<&mut T>; pub fn set(&self, value: T) -> Result<(), T>; pub fn get_or_init<F>(&self, f: F) -> &T where F: FnOnce() -> T; pub fn into_inner(self) -> Option<T>; pub fn take(&mut self) -> Option<T>; } impl<T: Clone> Clone for OnceCell<T>; impl<T: Debug> Debug for OnceCell<T> impl<T> Default for OnceCell<T>; impl<T> From<T> for OnceCell<T>; impl<T: PartialEq> PartialEq for OnceCell<T>; impl<T: Eq> Eq for OnceCell<T>; ``` ```rust // std::sync (in std/sync/once_lock.rs) impl<T> OnceLock<T> { pub const fn new() -> OnceLock<T>; pub fn get(&self) -> Option<&T>; pub fn get_mut(&mut self) -> Option<&mut T>; pub fn set(&self, value: T) -> Result<(), T>; pub fn get_or_init<F>(&self, f: F) -> &T where F: FnOnce() -> T; pub fn into_inner(self) -> Option<T>; pub fn take(&mut self) -> Option<T>; } impl<T: Clone> Clone for OnceLock<T>; impl<T: Debug> Debug for OnceLock<T>; impl<T> Default for OnceLock<T>; impl<#[may_dangle] T> Drop for OnceLock<T>; impl<T> From<T> for OnceLock<T>; impl<T: PartialEq> PartialEq for OnceLock<T> impl<T: Eq> Eq for OnceLock<T>; impl<T: RefUnwindSafe + UnwindSafe> RefUnwindSafe for OnceLock<T>; unsafe impl<T: Send> Send for OnceLock<T>; unsafe impl<T: Sync + Send> Sync for OnceLock<T>; impl<T: UnwindSafe> UnwindSafe for OnceLock<T>; ``` No longer planned as part of this PR, and moved to the `rust_cell_try` feature gate: ```rust impl<T> OnceCell<T> { pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E> where F: FnOnce() -> Result<T, E>; } impl<T> OnceLock<T> { pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E> where F: FnOnce() -> Result<T, E>; } ``` I am new to this process so would appreciate mentorship wherever needed. 2023-03-29T22:04:44+00:00 Trevor Gross tmgross@umich.edu 2022-12-12T05:42:45+00:00 urn:sha1:dc4ba57566acac492df2c2074d2d7144566dc7df Move items not part of this stabilization to 'lazy_cell' or 'once_cell_try'