mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Bump version placeholders

Browse Source
This commit is contained in:
Mark Rousskov 2024-02-03 16:37:58 -05:00
parent af88f7db51
commit 8043821b3a
17 changed files with 47 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_feature/src/accepted.rs
View File

@ -77,7 +77,7 @@ macro_rules! declare_features {
/// Allows empty structs and enum variants with braces. /// Allows empty structs and enum variants with braces.
(accepted, braced_empty_structs, "1.8.0", Some(29720)), (accepted, braced_empty_structs, "1.8.0", Some(29720)),
/// Allows `c"foo"` literals. /// Allows `c"foo"` literals.
(accepted, c_str_literals, "CURRENT_RUSTC_VERSION", Some(105723)), (accepted, c_str_literals, "1.77.0", Some(105723)),
/// Allows `#[cfg_attr(predicate, multiple, attributes, here)]`. /// Allows `#[cfg_attr(predicate, multiple, attributes, here)]`.
(accepted, cfg_attr_multi, "1.33.0", Some(54881)), (accepted, cfg_attr_multi, "1.33.0", Some(54881)),
/// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests. /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests.

2
compiler/rustc_feature/src/removed.rs
View File

@ -33,7 +33,7 @@ macro_rules! declare_features {
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/// Allows using the `amdgpu-kernel` ABI. /// Allows using the `amdgpu-kernel` ABI.
(removed, abi_amdgpu_kernel, "CURRENT_RUSTC_VERSION", Some(51575), None), (removed, abi_amdgpu_kernel, "1.77.0", Some(51575), None),
(removed, advanced_slice_patterns, "1.0.0", Some(62254), (removed, advanced_slice_patterns, "1.0.0", Some(62254),
Some("merged into `#![feature(slice_patterns)]`")), Some("merged into `#![feature(slice_patterns)]`")),
(removed, allocator, "1.0.0", None, None), (removed, allocator, "1.0.0", None, None),

8
compiler/rustc_feature/src/unstable.rs
View File

@ -356,7 +356,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
/// Allows `#[track_caller]` on async functions. /// Allows `#[track_caller]` on async functions.
(unstable, async_fn_track_caller, "1.73.0", Some(110011)), (unstable, async_fn_track_caller, "1.73.0", Some(110011)),
/// Allows `for await` loops. /// Allows `for await` loops.
(unstable, async_for_loop, "CURRENT_RUSTC_VERSION", Some(118898)), (unstable, async_for_loop, "1.77.0", Some(118898)),
/// Allows builtin # foo() syntax /// Allows builtin # foo() syntax
(unstable, builtin_syntax, "1.71.0", Some(110680)), (unstable, builtin_syntax, "1.71.0", Some(110680)),
/// Treat `extern "C"` function as nounwind. /// Treat `extern "C"` function as nounwind.
@ -370,7 +370,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
/// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used. /// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used.
(unstable, cfg_sanitize, "1.41.0", Some(39699)), (unstable, cfg_sanitize, "1.41.0", Some(39699)),
/// Allows `cfg(sanitizer_cfi_generalize_pointers)` and `cfg(sanitizer_cfi_normalize_integers)`. /// Allows `cfg(sanitizer_cfi_generalize_pointers)` and `cfg(sanitizer_cfi_normalize_integers)`.
(unstable, cfg_sanitizer_cfi, "CURRENT_RUSTC_VERSION", Some(89653)), (unstable, cfg_sanitizer_cfi, "1.77.0", Some(89653)),
/// Allows `cfg(target_abi = "...")`. /// Allows `cfg(target_abi = "...")`.
(unstable, cfg_target_abi, "1.55.0", Some(80970)), (unstable, cfg_target_abi, "1.55.0", Some(80970)),
/// Allows `cfg(target(abi = "..."))`. /// Allows `cfg(target(abi = "..."))`.
@ -514,7 +514,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
(unstable, marker_trait_attr, "1.30.0", Some(29864)), (unstable, marker_trait_attr, "1.30.0", Some(29864)),
/// Allows exhaustive pattern matching on types that contain uninhabited types in cases that are /// Allows exhaustive pattern matching on types that contain uninhabited types in cases that are
/// unambiguously sound. /// unambiguously sound.
(incomplete, min_exhaustive_patterns, "CURRENT_RUSTC_VERSION", Some(119612)), (incomplete, min_exhaustive_patterns, "1.77.0", Some(119612)),
/// A minimal, sound subset of specialization intended to be used by the /// A minimal, sound subset of specialization intended to be used by the
/// standard library until the soundness issues with specialization /// standard library until the soundness issues with specialization
/// are fixed. /// are fixed.
@ -550,7 +550,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
/// Allows using enums in offset_of! /// Allows using enums in offset_of!
(unstable, offset_of_enum, "1.75.0", Some(120141)), (unstable, offset_of_enum, "1.75.0", Some(120141)),
/// Allows using multiple nested field accesses in offset_of! /// Allows using multiple nested field accesses in offset_of!
(unstable, offset_of_nested, "CURRENT_RUSTC_VERSION", Some(120140)), (unstable, offset_of_nested, "1.77.0", Some(120140)),
/// Allows using `#[optimize(X)]`. /// Allows using `#[optimize(X)]`.
(unstable, optimize_attribute, "1.34.0", Some(54882)), (unstable, optimize_attribute, "1.34.0", Some(54882)),
/// Allows macro attributes on expressions, statements and non-inline modules. /// Allows macro attributes on expressions, statements and non-inline modules.

2
library/alloc/src/slice.rs
View File

@ -51,7 +51,7 @@
pub use core::slice::{from_mut_ptr_range, from_ptr_range}; pub use core::slice::{from_mut_ptr_range, from_ptr_range};
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub use core::slice::{from_raw_parts, from_raw_parts_mut}; pub use core::slice::{from_raw_parts, from_raw_parts_mut};
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
pub use core::slice::{ChunkBy, ChunkByMut}; pub use core::slice::{ChunkBy, ChunkByMut};
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub use core::slice::{Chunks, Windows}; pub use core::slice::{Chunks, Windows};

2
library/alloc/src/vec/cow.rs
View File

@ -15,7 +15,7 @@ fn from(s: &'a [T]) -> Cow<'a, [T]> {
} }
} }
#[stable(feature = "cow_from_array_ref", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "cow_from_array_ref", since = "1.77.0")]
impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]> { impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]> {
/// Creates a [`Borrowed`] variant of [`Cow`] /// Creates a [`Borrowed`] variant of [`Cow`]
/// from a reference to an array. /// from a reference to an array.

4
library/core/src/array/mod.rs
View File

@ -576,7 +576,7 @@ pub fn as_mut_slice(&mut self) -> &mut [T] {
/// // We can still access the original array: it has not been moved. /// // We can still access the original array: it has not been moved.
/// assert_eq!(strings.len(), 3); /// assert_eq!(strings.len(), 3);
/// ``` /// ```
#[stable(feature = "array_methods", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "array_methods", since = "1.77.0")]
pub fn each_ref(&self) -> [&T; N] { pub fn each_ref(&self) -> [&T; N] {
from_trusted_iterator(self.iter()) from_trusted_iterator(self.iter())
} }
@ -595,7 +595,7 @@ pub fn as_mut_slice(&mut self) -> &mut [T] {
/// assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]); /// assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
/// assert_eq!(floats, [0.0, 2.7, -1.0]); /// assert_eq!(floats, [0.0, 2.7, -1.0]);
/// ``` /// ```
#[stable(feature = "array_methods", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "array_methods", since = "1.77.0")]
pub fn each_mut(&mut self) -> [&mut T; N] { pub fn each_mut(&mut self) -> [&mut T; N] {
from_trusted_iterator(self.iter_mut()) from_trusted_iterator(self.iter_mut())
} }

2
library/core/src/intrinsics.rs
View File

@ -947,7 +947,7 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
/// own, or if it does not enable any significant optimizations. /// own, or if it does not enable any significant optimizations.
/// ///
/// This intrinsic does not have a stable counterpart. /// This intrinsic does not have a stable counterpart.
#[rustc_const_stable(feature = "const_assume", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_stable(feature = "const_assume", since = "1.77.0")]
#[rustc_nounwind] #[rustc_nounwind]
pub fn assume(b: bool); pub fn assume(b: bool);

4
library/core/src/mem/mod.rs
View File

@ -1394,7 +1394,7 @@ impl<T> SizedTypeProperties for T {}
/// assert_eq!(mem::offset_of!(Option<&u8>, Some.0), 0); /// assert_eq!(mem::offset_of!(Option<&u8>, Some.0), 0);
/// ``` /// ```
#[cfg(not(bootstrap))] #[cfg(not(bootstrap))]
#[stable(feature = "offset_of", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "offset_of", since = "1.77.0")]
#[allow_internal_unstable(builtin_syntax, hint_must_use)] #[allow_internal_unstable(builtin_syntax, hint_must_use)]
pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) { pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) {
// The `{}` is for better error messages // The `{}` is for better error messages
@ -1402,7 +1402,7 @@ impl<T> SizedTypeProperties for T {}
} }
#[cfg(bootstrap)] #[cfg(bootstrap)]
#[stable(feature = "offset_of", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "offset_of", since = "1.77.0")]
#[allow_internal_unstable(builtin_syntax, hint_must_use)] #[allow_internal_unstable(builtin_syntax, hint_must_use)]
#[allow(missing_docs)] #[allow(missing_docs)]
pub macro offset_of($Container:ty, $($fields:tt).+ $(,)?) { pub macro offset_of($Container:ty, $($fields:tt).+ $(,)?) {

2
library/core/src/net/mod.rs
View File

@ -9,7 +9,7 @@
//! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`] //! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`]
//! and [`SocketAddrV6`] are respectively IPv4 and IPv6 socket addresses //! and [`SocketAddrV6`] are respectively IPv4 and IPv6 socket addresses
#![stable(feature = "ip_in_core", since = "CURRENT_RUSTC_VERSION")] #![stable(feature = "ip_in_core", since = "1.77.0")]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub use self::ip_addr::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope}; pub use self::ip_addr::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};

2
library/core/src/ops/range.rs
View File

@ -726,7 +726,7 @@ pub fn as_mut(&mut self) -> Bound<&mut T> {
/// assert_eq!(unbounded_string.map(|s| s.len()), Unbounded); /// assert_eq!(unbounded_string.map(|s| s.len()), Unbounded);
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "bound_map", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "bound_map", since = "1.77.0")]
pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Bound<U> { pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Bound<U> {
match self { match self {
Unbounded => Unbounded, Unbounded => Unbounded,

24
library/core/src/slice/iter.rs
View File

@ -3252,21 +3252,21 @@ unsafe impl<'a, T> TrustedRandomAccessNoCoerce for IterMut<'a, T> {
/// ///
/// [`chunk_by`]: slice::chunk_by /// [`chunk_by`]: slice::chunk_by
/// [slices]: slice /// [slices]: slice
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
#[must_use = "iterators are lazy and do nothing unless consumed"] #[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct ChunkBy<'a, T: 'a, P> { pub struct ChunkBy<'a, T: 'a, P> {
slice: &'a [T], slice: &'a [T],
predicate: P, predicate: P,
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> ChunkBy<'a, T, P> { impl<'a, T: 'a, P> ChunkBy<'a, T, P> {
pub(super) fn new(slice: &'a [T], predicate: P) -> Self { pub(super) fn new(slice: &'a [T], predicate: P) -> Self {
ChunkBy { slice, predicate } ChunkBy { slice, predicate }
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> Iterator for ChunkBy<'a, T, P> impl<'a, T: 'a, P> Iterator for ChunkBy<'a, T, P>
where where
P: FnMut(&T, &T) -> bool, P: FnMut(&T, &T) -> bool,
@ -3300,7 +3300,7 @@ fn last(mut self) -> Option<Self::Item> {
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> DoubleEndedIterator for ChunkBy<'a, T, P> impl<'a, T: 'a, P> DoubleEndedIterator for ChunkBy<'a, T, P>
where where
P: FnMut(&T, &T) -> bool, P: FnMut(&T, &T) -> bool,
@ -3322,10 +3322,10 @@ fn next_back(&mut self) -> Option<Self::Item> {
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> FusedIterator for ChunkBy<'a, T, P> where P: FnMut(&T, &T) -> bool {} impl<'a, T: 'a, P> FusedIterator for ChunkBy<'a, T, P> where P: FnMut(&T, &T) -> bool {}
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkBy<'a, T, P> { impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkBy<'a, T, P> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ChunkBy").field("slice", &self.slice).finish() f.debug_struct("ChunkBy").field("slice", &self.slice).finish()
@ -3339,21 +3339,21 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
/// ///
/// [`chunk_by_mut`]: slice::chunk_by_mut /// [`chunk_by_mut`]: slice::chunk_by_mut
/// [slices]: slice /// [slices]: slice
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
#[must_use = "iterators are lazy and do nothing unless consumed"] #[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct ChunkByMut<'a, T: 'a, P> { pub struct ChunkByMut<'a, T: 'a, P> {
slice: &'a mut [T], slice: &'a mut [T],
predicate: P, predicate: P,
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> ChunkByMut<'a, T, P> { impl<'a, T: 'a, P> ChunkByMut<'a, T, P> {
pub(super) fn new(slice: &'a mut [T], predicate: P) -> Self { pub(super) fn new(slice: &'a mut [T], predicate: P) -> Self {
ChunkByMut { slice, predicate } ChunkByMut { slice, predicate }
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> Iterator for ChunkByMut<'a, T, P> impl<'a, T: 'a, P> Iterator for ChunkByMut<'a, T, P>
where where
P: FnMut(&T, &T) -> bool, P: FnMut(&T, &T) -> bool,
@ -3388,7 +3388,7 @@ fn last(mut self) -> Option<Self::Item> {
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> DoubleEndedIterator for ChunkByMut<'a, T, P> impl<'a, T: 'a, P> DoubleEndedIterator for ChunkByMut<'a, T, P>
where where
P: FnMut(&T, &T) -> bool, P: FnMut(&T, &T) -> bool,
@ -3411,10 +3411,10 @@ fn next_back(&mut self) -> Option<Self::Item> {
} }
} }
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a, P> FusedIterator for ChunkByMut<'a, T, P> where P: FnMut(&T, &T) -> bool {} impl<'a, T: 'a, P> FusedIterator for ChunkByMut<'a, T, P> where P: FnMut(&T, &T) -> bool {}
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkByMut<'a, T, P> { impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkByMut<'a, T, P> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ChunkByMut").field("slice", &self.slice).finish() f.debug_struct("ChunkByMut").field("slice", &self.slice).finish()

30
library/core/src/slice/mod.rs
View File

@ -68,7 +68,7 @@
#[unstable(feature = "array_windows", issue = "75027")] #[unstable(feature = "array_windows", issue = "75027")]
pub use iter::ArrayWindows; pub use iter::ArrayWindows;
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
pub use iter::{ChunkBy, ChunkByMut}; pub use iter::{ChunkBy, ChunkByMut};
#[stable(feature = "split_inclusive", since = "1.51.0")] #[stable(feature = "split_inclusive", since = "1.51.0")]
@ -334,8 +334,8 @@ pub const fn last_mut(&mut self) -> Option<&mut T> {
/// assert_eq!(Some(&[]), w.first_chunk::<0>()); /// assert_eq!(Some(&[]), w.first_chunk::<0>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_stable(feature = "slice_first_last_chunk", since = "1.77.0")]
pub const fn first_chunk<const N: usize>(&self) -> Option<&[T; N]> { pub const fn first_chunk<const N: usize>(&self) -> Option<&[T; N]> {
if self.len() < N { if self.len() < N {
None None
@ -364,7 +364,7 @@ pub const fn last_mut(&mut self) -> Option<&mut T> {
/// assert_eq!(None, x.first_chunk_mut::<4>()); /// assert_eq!(None, x.first_chunk_mut::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")] #[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")]
pub const fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]> { pub const fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]> {
if self.len() < N { if self.len() < N {
@ -394,8 +394,8 @@ pub const fn last_mut(&mut self) -> Option<&mut T> {
/// assert_eq!(None, x.split_first_chunk::<4>()); /// assert_eq!(None, x.split_first_chunk::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_stable(feature = "slice_first_last_chunk", since = "1.77.0")]
pub const fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])> { pub const fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])> {
if self.len() < N { if self.len() < N {
None None
@ -429,7 +429,7 @@ pub const fn last_mut(&mut self) -> Option<&mut T> {
/// assert_eq!(None, x.split_first_chunk_mut::<4>()); /// assert_eq!(None, x.split_first_chunk_mut::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")] #[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")]
pub const fn split_first_chunk_mut<const N: usize>( pub const fn split_first_chunk_mut<const N: usize>(
&mut self, &mut self,
@ -464,8 +464,8 @@ pub const fn split_first_chunk_mut<const N: usize>(
/// assert_eq!(None, x.split_last_chunk::<4>()); /// assert_eq!(None, x.split_last_chunk::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_stable(feature = "slice_first_last_chunk", since = "1.77.0")]
pub const fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])> { pub const fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])> {
if self.len() < N { if self.len() < N {
None None
@ -499,7 +499,7 @@ pub const fn split_first_chunk_mut<const N: usize>(
/// assert_eq!(None, x.split_last_chunk_mut::<4>()); /// assert_eq!(None, x.split_last_chunk_mut::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")] #[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")]
pub const fn split_last_chunk_mut<const N: usize>( pub const fn split_last_chunk_mut<const N: usize>(
&mut self, &mut self,
@ -534,7 +534,7 @@ pub const fn split_last_chunk_mut<const N: usize>(
/// assert_eq!(Some(&[]), w.last_chunk::<0>()); /// assert_eq!(Some(&[]), w.last_chunk::<0>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")] #[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")]
pub const fn last_chunk<const N: usize>(&self) -> Option<&[T; N]> { pub const fn last_chunk<const N: usize>(&self) -> Option<&[T; N]> {
if self.len() < N { if self.len() < N {
@ -568,7 +568,7 @@ pub const fn split_last_chunk_mut<const N: usize>(
/// assert_eq!(None, x.last_chunk_mut::<4>()); /// assert_eq!(None, x.last_chunk_mut::<4>());
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_first_last_chunk", since = "1.77.0")]
#[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")] #[rustc_const_unstable(feature = "const_slice_first_last_chunk", issue = "111774")]
pub const fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]> { pub const fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]> {
if self.len() < N { if self.len() < N {
@ -1777,7 +1777,7 @@ pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T>
/// assert_eq!(iter.next(), Some(&[2, 3, 4][..])); /// assert_eq!(iter.next(), Some(&[2, 3, 4][..]));
/// assert_eq!(iter.next(), None); /// assert_eq!(iter.next(), None);
/// ``` /// ```
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
#[inline] #[inline]
pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F> pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F>
where where
@ -1818,7 +1818,7 @@ pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F>
/// assert_eq!(iter.next(), Some(&mut [2, 3, 4][..])); /// assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
/// assert_eq!(iter.next(), None); /// assert_eq!(iter.next(), None);
/// ``` /// ```
#[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "slice_group_by", since = "1.77.0")]
#[inline] #[inline]
pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F> pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F>
where where
@ -1953,7 +1953,7 @@ pub const fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
#[unstable(feature = "slice_split_at_unchecked", reason = "new API", issue = "76014")] #[unstable(feature = "slice_split_at_unchecked", reason = "new API", issue = "76014")]
#[rustc_const_stable( #[rustc_const_stable(
feature = "const_slice_split_at_unchecked", feature = "const_slice_split_at_unchecked",
since = "CURRENT_RUSTC_VERSION" since = "1.77.0"
)] )]
#[inline] #[inline]
#[must_use] #[must_use]

2
library/std/src/f32.rs
View File

@ -114,7 +114,7 @@ pub fn round(self) -> f32 {
/// ``` /// ```
#[rustc_allow_incoherent_impl] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "round_ties_even", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "round_ties_even", since = "1.77.0")]
#[inline] #[inline]
pub fn round_ties_even(self) -> f32 { pub fn round_ties_even(self) -> f32 {
unsafe { intrinsics::rintf32(self) } unsafe { intrinsics::rintf32(self) }

2
library/std/src/f64.rs
View File

@ -114,7 +114,7 @@ pub fn round(self) -> f64 {
/// ``` /// ```
#[rustc_allow_incoherent_impl] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "round_ties_even", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "round_ties_even", since = "1.77.0")]
#[inline] #[inline]
pub fn round_ties_even(self) -> f64 { pub fn round_ties_even(self) -> f64 {
unsafe { intrinsics::rintf64(self) } unsafe { intrinsics::rintf64(self) }

2
library/std/src/fs.rs
View File

@ -428,7 +428,7 @@ pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File> {
/// Ok(()) /// Ok(())
/// } /// }
/// ``` /// ```
#[stable(feature = "file_create_new", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "file_create_new", since = "1.77.0")]
pub fn create_new<P: AsRef<Path>>(path: P) -> io::Result<File> { pub fn create_new<P: AsRef<Path>>(path: P) -> io::Result<File> {
OpenOptions::new().read(true).write(true).create_new(true).open(path.as_ref()) OpenOptions::new().read(true).write(true).create_new(true).open(path.as_ref())
} }

2
library/std/src/sync/mutex.rs
View File

@ -404,7 +404,7 @@ pub fn is_poisoned(&self) -> bool {
/// assert_eq!(*x, 1); /// assert_eq!(*x, 1);
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "mutex_unpoison", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "mutex_unpoison", since = "1.77.0")]
pub fn clear_poison(&self) { pub fn clear_poison(&self) {
self.poison.clear(); self.poison.clear();
} }

2
library/std/src/sync/rwlock.rs
View File

@ -408,7 +408,7 @@ pub fn is_poisoned(&self) -> bool {
/// assert_eq!(*guard, 1); /// assert_eq!(*guard, 1);
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "mutex_unpoison", since = "CURRENT_RUSTC_VERSION")] #[stable(feature = "mutex_unpoison", since = "1.77.0")]
pub fn clear_poison(&self) { pub fn clear_poison(&self) {
self.poison.clear(); self.poison.clear();
} }