From 8043821b3aa7267f56cc4a73f7edcdf9d8d1614e Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Sat, 3 Feb 2024 16:37:58 -0500 Subject: [PATCH] Bump version placeholders --- compiler/rustc_feature/src/accepted.rs | 2 +- compiler/rustc_feature/src/removed.rs | 2 +- compiler/rustc_feature/src/unstable.rs | 8 +++---- library/alloc/src/slice.rs | 2 +- library/alloc/src/vec/cow.rs | 2 +- library/core/src/array/mod.rs | 4 ++-- library/core/src/intrinsics.rs | 2 +- library/core/src/mem/mod.rs | 4 ++-- library/core/src/net/mod.rs | 2 +- library/core/src/ops/range.rs | 2 +- library/core/src/slice/iter.rs | 24 ++++++++++----------- library/core/src/slice/mod.rs | 30 +++++++++++++------------- library/std/src/f32.rs | 2 +- library/std/src/f64.rs | 2 +- library/std/src/fs.rs | 2 +- library/std/src/sync/mutex.rs | 2 +- library/std/src/sync/rwlock.rs | 2 +- 17 files changed, 47 insertions(+), 47 deletions(-) diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index 1155366db85..18f6ae35054 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/compiler/rustc_feature/src/accepted.rs @@ -77,7 +77,7 @@ macro_rules! declare_features { /// Allows empty structs and enum variants with braces. (accepted, braced_empty_structs, "1.8.0", Some(29720)), /// 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)]`. (accepted, cfg_attr_multi, "1.33.0", Some(54881)), /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests. diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs index 040892df4c3..008c59e1be3 100644 --- a/compiler/rustc_feature/src/removed.rs +++ b/compiler/rustc_feature/src/removed.rs @@ -33,7 +33,7 @@ macro_rules! declare_features { // ------------------------------------------------------------------------- /// 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), Some("merged into `#![feature(slice_patterns)]`")), (removed, allocator, "1.0.0", None, None), diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 1fb91ff8bbc..42fc24c937b 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/compiler/rustc_feature/src/unstable.rs @@ -356,7 +356,7 @@ pub fn internal(&self, feature: Symbol) -> bool { /// Allows `#[track_caller]` on async functions. (unstable, async_fn_track_caller, "1.73.0", Some(110011)), /// 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 (unstable, builtin_syntax, "1.71.0", Some(110680)), /// 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. (unstable, cfg_sanitize, "1.41.0", Some(39699)), /// 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 = "...")`. (unstable, cfg_target_abi, "1.55.0", Some(80970)), /// Allows `cfg(target(abi = "..."))`. @@ -514,7 +514,7 @@ pub fn internal(&self, feature: Symbol) -> bool { (unstable, marker_trait_attr, "1.30.0", Some(29864)), /// Allows exhaustive pattern matching on types that contain uninhabited types in cases that are /// 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 /// standard library until the soundness issues with specialization /// are fixed. @@ -550,7 +550,7 @@ pub fn internal(&self, feature: Symbol) -> bool { /// Allows using enums in offset_of! (unstable, offset_of_enum, "1.75.0", Some(120141)), /// 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)]`. (unstable, optimize_attribute, "1.34.0", Some(54882)), /// Allows macro attributes on expressions, statements and non-inline modules. diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index 4033f4eb068..f4e392760c8 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -51,7 +51,7 @@ pub use core::slice::{from_mut_ptr_range, from_ptr_range}; #[stable(feature = "rust1", since = "1.0.0")] 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}; #[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{Chunks, Windows}; diff --git a/library/alloc/src/vec/cow.rs b/library/alloc/src/vec/cow.rs index b12910f3690..3fe83242a30 100644 --- a/library/alloc/src/vec/cow.rs +++ b/library/alloc/src/vec/cow.rs @@ -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]> { /// Creates a [`Borrowed`] variant of [`Cow`] /// from a reference to an array. diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs index 85cce81f2c1..743f07644e3 100644 --- a/library/core/src/array/mod.rs +++ b/library/core/src/array/mod.rs @@ -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. /// 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] { 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!(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] { from_trusted_iterator(self.iter_mut()) } diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 6ea80c8d42f..cdfdaa9e70c 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -947,7 +947,7 @@ pub unsafe fn drop_in_place(to_drop: *mut T) { /// own, or if it does not enable any significant optimizations. /// /// 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] pub fn assume(b: bool); diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs index 318a99e23ec..ab5b89764e9 100644 --- a/library/core/src/mem/mod.rs +++ b/library/core/src/mem/mod.rs @@ -1394,7 +1394,7 @@ impl SizedTypeProperties for T {} /// assert_eq!(mem::offset_of!(Option<&u8>, Some.0), 0); /// ``` #[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)] pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) { // The `{}` is for better error messages @@ -1402,7 +1402,7 @@ impl SizedTypeProperties for T {} } #[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(missing_docs)] pub macro offset_of($Container:ty, $($fields:tt).+ $(,)?) { diff --git a/library/core/src/net/mod.rs b/library/core/src/net/mod.rs index 5bae4d2f0c4..0786165fe9e 100644 --- a/library/core/src/net/mod.rs +++ b/library/core/src/net/mod.rs @@ -9,7 +9,7 @@ //! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`] //! 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")] pub use self::ip_addr::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope}; diff --git a/library/core/src/ops/range.rs b/library/core/src/ops/range.rs index e809273c9ed..727a22e454d 100644 --- a/library/core/src/ops/range.rs +++ b/library/core/src/ops/range.rs @@ -726,7 +726,7 @@ pub fn as_mut(&mut self) -> Bound<&mut T> { /// assert_eq!(unbounded_string.map(|s| s.len()), Unbounded); /// ``` #[inline] - #[stable(feature = "bound_map", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "bound_map", since = "1.77.0")] pub fn map U>(self, f: F) -> Bound { match self { Unbounded => Unbounded, diff --git a/library/core/src/slice/iter.rs b/library/core/src/slice/iter.rs index 2d4c7e78aea..1fb1df35e27 100644 --- a/library/core/src/slice/iter.rs +++ b/library/core/src/slice/iter.rs @@ -3252,21 +3252,21 @@ unsafe impl<'a, T> TrustedRandomAccessNoCoerce for IterMut<'a, T> { /// /// [`chunk_by`]: slice::chunk_by /// [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"] pub struct ChunkBy<'a, T: 'a, P> { slice: &'a [T], 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> { pub(super) fn new(slice: &'a [T], predicate: P) -> Self { 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> where P: FnMut(&T, &T) -> bool, @@ -3300,7 +3300,7 @@ fn last(mut self) -> Option { } } -#[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> where P: FnMut(&T, &T) -> bool, @@ -3322,10 +3322,10 @@ fn next_back(&mut self) -> Option { } } -#[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 {} -#[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> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 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 /// [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"] pub struct ChunkByMut<'a, T: 'a, P> { slice: &'a mut [T], 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> { pub(super) fn new(slice: &'a mut [T], predicate: P) -> Self { 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> where P: FnMut(&T, &T) -> bool, @@ -3388,7 +3388,7 @@ fn last(mut self) -> Option { } } -#[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> where P: FnMut(&T, &T) -> bool, @@ -3411,10 +3411,10 @@ fn next_back(&mut self) -> Option { } } -#[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 {} -#[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> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("ChunkByMut").field("slice", &self.slice).finish() diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index 4ed22ede03a..d2cbf8396b6 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -68,7 +68,7 @@ #[unstable(feature = "array_windows", issue = "75027")] 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}; #[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>()); /// ``` #[inline] - #[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_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 = "1.77.0")] pub const fn first_chunk(&self) -> Option<&[T; N]> { if self.len() < N { None @@ -364,7 +364,7 @@ pub const fn last_mut(&mut self) -> Option<&mut T> { /// assert_eq!(None, x.first_chunk_mut::<4>()); /// ``` #[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")] pub const fn first_chunk_mut(&mut self) -> Option<&mut [T; 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>()); /// ``` #[inline] - #[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_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 = "1.77.0")] pub const fn split_first_chunk(&self) -> Option<(&[T; N], &[T])> { if self.len() < N { None @@ -429,7 +429,7 @@ pub const fn last_mut(&mut self) -> Option<&mut T> { /// assert_eq!(None, x.split_first_chunk_mut::<4>()); /// ``` #[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")] pub const fn split_first_chunk_mut( &mut self, @@ -464,8 +464,8 @@ pub const fn split_first_chunk_mut( /// assert_eq!(None, x.split_last_chunk::<4>()); /// ``` #[inline] - #[stable(feature = "slice_first_last_chunk", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_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 = "1.77.0")] pub const fn split_last_chunk(&self) -> Option<(&[T], &[T; N])> { if self.len() < N { None @@ -499,7 +499,7 @@ pub const fn split_first_chunk_mut( /// assert_eq!(None, x.split_last_chunk_mut::<4>()); /// ``` #[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")] pub const fn split_last_chunk_mut( &mut self, @@ -534,7 +534,7 @@ pub const fn split_last_chunk_mut( /// assert_eq!(Some(&[]), w.last_chunk::<0>()); /// ``` #[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")] pub const fn last_chunk(&self) -> Option<&[T; N]> { if self.len() < N { @@ -568,7 +568,7 @@ pub const fn split_last_chunk_mut( /// assert_eq!(None, x.last_chunk_mut::<4>()); /// ``` #[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")] pub const fn last_chunk_mut(&mut self) -> Option<&mut [T; 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(), None); /// ``` - #[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "slice_group_by", since = "1.77.0")] #[inline] pub fn chunk_by(&self, pred: F) -> ChunkBy<'_, T, F> where @@ -1818,7 +1818,7 @@ pub fn chunk_by(&self, pred: F) -> ChunkBy<'_, T, F> /// assert_eq!(iter.next(), Some(&mut [2, 3, 4][..])); /// assert_eq!(iter.next(), None); /// ``` - #[stable(feature = "slice_group_by", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "slice_group_by", since = "1.77.0")] #[inline] pub fn chunk_by_mut(&mut self, pred: F) -> ChunkByMut<'_, T, F> 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")] #[rustc_const_stable( feature = "const_slice_split_at_unchecked", - since = "CURRENT_RUSTC_VERSION" + since = "1.77.0" )] #[inline] #[must_use] diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs index 1b38ba72114..b60d7a72411 100644 --- a/library/std/src/f32.rs +++ b/library/std/src/f32.rs @@ -114,7 +114,7 @@ pub fn round(self) -> f32 { /// ``` #[rustc_allow_incoherent_impl] #[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] pub fn round_ties_even(self) -> f32 { unsafe { intrinsics::rintf32(self) } diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs index f8fc84440ae..88f992b3957 100644 --- a/library/std/src/f64.rs +++ b/library/std/src/f64.rs @@ -114,7 +114,7 @@ pub fn round(self) -> f64 { /// ``` #[rustc_allow_incoherent_impl] #[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] pub fn round_ties_even(self) -> f64 { unsafe { intrinsics::rintf64(self) } diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs index 80d369eb067..3383a8cfa41 100644 --- a/library/std/src/fs.rs +++ b/library/std/src/fs.rs @@ -428,7 +428,7 @@ pub fn create>(path: P) -> io::Result { /// Ok(()) /// } /// ``` - #[stable(feature = "file_create_new", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "file_create_new", since = "1.77.0")] pub fn create_new>(path: P) -> io::Result { OpenOptions::new().read(true).write(true).create_new(true).open(path.as_ref()) } diff --git a/library/std/src/sync/mutex.rs b/library/std/src/sync/mutex.rs index 184c406e326..920143b7ac7 100644 --- a/library/std/src/sync/mutex.rs +++ b/library/std/src/sync/mutex.rs @@ -404,7 +404,7 @@ pub fn is_poisoned(&self) -> bool { /// assert_eq!(*x, 1); /// ``` #[inline] - #[stable(feature = "mutex_unpoison", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "mutex_unpoison", since = "1.77.0")] pub fn clear_poison(&self) { self.poison.clear(); } diff --git a/library/std/src/sync/rwlock.rs b/library/std/src/sync/rwlock.rs index 23d3dd0707a..c5d846b85aa 100644 --- a/library/std/src/sync/rwlock.rs +++ b/library/std/src/sync/rwlock.rs @@ -408,7 +408,7 @@ pub fn is_poisoned(&self) -> bool { /// assert_eq!(*guard, 1); /// ``` #[inline] - #[stable(feature = "mutex_unpoison", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "mutex_unpoison", since = "1.77.0")] pub fn clear_poison(&self) { self.poison.clear(); }