Stabilize atomic_try_update

and deprecate fetch_update starting 1.96.0

Author: GrigorenkoPV

library/alloc/src/sync.rs

@@ -3186,7 +3186,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
         // Acquire is necessary for the success case to synchronise with `Arc::new_cyclic`, when the inner
         // value can be initialized after `Weak` references have already been created. In that case, we
         // expect to observe the fully initialized value.
-        if self.inner()?.strong.fetch_update(Acquire, Relaxed, checked_increment).is_ok() {
+        if self.inner()?.strong.try_update(Acquire, Relaxed, checked_increment).is_ok() {
             // SAFETY: pointer is not null, verified in checked_increment
             unsafe { Some(Arc::from_inner_in(self.ptr, self.alloc.clone())) }
         } else {

library/core/src/alloc/global.rs

@@ -57,7 +57,7 @@ use crate::{cmp, ptr};
 ///         let mut allocated = 0;
 ///         if self
 ///             .remaining
-///             .fetch_update(Relaxed, Relaxed, |mut remaining| {
+///             .try_update(Relaxed, Relaxed, |mut remaining| {
 ///                 if size > remaining {
 ///                     return None;
 ///                 }

library/core/src/sync/atomic.rs

@@ -38,7 +38,7 @@ impl Condvar {
         // possible for `counter` to decrease due to a condvar timing out, in which
         // case the corresponding `timed_out` will increase accordingly.
         let Ok(waiter_count) =
-            self.counter.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |counter| {
+            self.counter.try_update(Ordering::Relaxed, Ordering::Relaxed, |counter| {
                 if counter == 0 {
                     return None;
                 } else {

library/std/src/sys/sync/condvar/xous.rs

@@ -86,7 +86,7 @@ impl RwLock {
     #[inline]
     pub fn try_read(&self) -> bool {
         self.state
-            .fetch_update(Acquire, Relaxed, |s| is_read_lockable(s).then(|| s + READ_LOCKED))
+            .try_update(Acquire, Relaxed, |s| is_read_lockable(s).then(|| s + READ_LOCKED))
             .is_ok()
     }
 
@@ -164,7 +164,7 @@ impl RwLock {
     #[inline]
     pub fn try_write(&self) -> bool {
         self.state
-            .fetch_update(Acquire, Relaxed, |s| is_unlocked(s).then(|| s + WRITE_LOCKED))
+            .try_update(Acquire, Relaxed, |s| is_unlocked(s).then(|| s + WRITE_LOCKED))
             .is_ok()
     }
 

library/std/src/sys/sync/rwlock/futex.rs

@@ -329,7 +329,7 @@ impl RwLock {
 
     #[inline]
     pub fn try_read(&self) -> bool {
-        self.state.fetch_update(Acquire, Relaxed, read_lock).is_ok()
+        self.state.try_update(Acquire, Relaxed, read_lock).is_ok()
     }
 
     #[inline]
@@ -343,7 +343,7 @@ impl RwLock {
     pub fn try_write(&self) -> bool {
         // Atomically set the `LOCKED` bit. This is lowered to a single atomic instruction on most
         // modern processors (e.g. "lock bts" on x86 and "ldseta" on modern AArch64), and therefore
-        // is more efficient than `fetch_update(lock(true))`, which can spuriously fail if a new
+        // is more efficient than `try_update(lock(true))`, which can spuriously fail if a new
         // node is appended to the queue.
         self.state.fetch_or(LOCKED, Acquire).addr() & LOCKED == 0
     }
@@ -453,7 +453,7 @@ impl RwLock {
 
     #[inline]
     pub unsafe fn read_unlock(&self) {
-        match self.state.fetch_update(Release, Acquire, |state| {
+        match self.state.try_update(Release, Acquire, |state| {
             if state.addr() & QUEUED == 0 {
                 // If there are no threads queued, simply decrement the reader count.
                 let count = state.addr() - (SINGLE | LOCKED);

library/std/src/sys/sync/rwlock/queue.rs

@@ -3,7 +3,6 @@
 
 #![allow(deprecated)]
 #![allow(dead_code)]
-#![feature(atomic_try_update)]
 
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU32, Ordering};
 

tests/ui/lint/const-item-interior-mutations-const-atomics.fixed

@@ -3,7 +3,6 @@
 
 #![allow(deprecated)]
 #![allow(dead_code)]
-#![feature(atomic_try_update)]
 
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicU32, Ordering};