Stabilize atomic_try_update

GrigorenkoPV · GrigorenkoPV · commit 7ffe34e9a5fc · 2025-11-09T15:33:10.000+03:00
and deprecate fetch_update starting 1.96.0
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
@@ -3181,7 +3181,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 {
diff --git a/library/core/src/alloc/global.rs b/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;
 ///                 }
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
diff --git a/library/std/src/sys/sync/condvar/xous.rs b/library/std/src/sys/sync/condvar/xous.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 {
diff --git a/library/std/src/sys/sync/rwlock/futex.rs b/library/std/src/sys/sync/rwlock/futex.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()
     }
 
diff --git a/library/std/src/sys/sync/rwlock/queue.rs b/library/std/src/sys/sync/rwlock/queue.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);
diff --git a/tests/ui/lint/lint-invalid-atomic-ordering-update.rs b/tests/ui/lint/lint-invalid-atomic-ordering-update.rs
@@ -1,6 +1,4 @@
 //@ only-x86_64
-#![feature(atomic_try_update)]
-
 use std::sync::atomic::{AtomicIsize, Ordering};
 
 fn main() {
diff --git a/tests/ui/lint/lint-invalid-atomic-ordering-update.stderr b/tests/ui/lint/lint-invalid-atomic-ordering-update.stderr
@@ -1,5 +1,5 @@
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:73:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:71:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^ invalid failure ordering
@@ -8,231 +8,231 @@ LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(
    = note: `#[deny(invalid_atomic_ordering)]` on by default
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:75:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:73:45
    |
 LL |     let _ = x.try_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:77:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:75:41
    |
 LL |     let _ = x.update(Ordering::Relaxed, Ordering::AcqRel, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:80:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:78:47
    |
 LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:82:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:80:45
    |
 LL |     let _ = x.try_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:84:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:82:41
    |
 LL |     let _ = x.update(Ordering::Acquire, Ordering::AcqRel, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:87:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:85:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:89:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:87:45
    |
 LL |     let _ = x.try_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:91:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:89:41
    |
 LL |     let _ = x.update(Ordering::Release, Ordering::AcqRel, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:94:46
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:92:46
    |
 LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:96:44
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:94:44
    |
 LL |     let _ = x.try_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
    |                                            ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:98:40
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:96:40
    |
 LL |     let _ = x.update(Ordering::AcqRel, Ordering::AcqRel, |old| old + 1);
    |                                        ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:101:46
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:99:46
    |
 LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:103:44
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:101:44
    |
 LL |     let _ = x.try_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
    |                                            ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:105:40
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:103:40
    |
 LL |     let _ = x.update(Ordering::SeqCst, Ordering::AcqRel, |old| old + 1);
    |                                        ^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:110:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:108:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:112:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:110:45
    |
 LL |     let _ = x.try_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:114:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:112:41
    |
 LL |     let _ = x.update(Ordering::Relaxed, Ordering::Release, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:117:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:115:47
    |
 LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:119:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:117:45
    |
 LL |     let _ = x.try_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:121:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:119:41
    |
 LL |     let _ = x.update(Ordering::Acquire, Ordering::Release, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:124:47
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:122:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:126:45
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:124:45
    |
 LL |     let _ = x.try_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
    |                                             ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:128:41
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:126:41
    |
 LL |     let _ = x.update(Ordering::Release, Ordering::Release, |old| old + 1);
    |                                         ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:131:46
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:129:46
    |
 LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:133:44
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:131:44
    |
 LL |     let _ = x.try_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
    |                                            ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:135:40
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:133:40
    |
 LL |     let _ = x.update(Ordering::AcqRel, Ordering::Release, |old| old + 1);
    |                                        ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:138:46
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:136:46
    |
 LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:140:44
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:138:44
    |
 LL |     let _ = x.try_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
    |                                            ^^^^^^^^^^^^^^^^^ invalid failure ordering
    |
    = help: consider using `Acquire` or `Relaxed` failure ordering instead
 
 error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
-  --> $DIR/lint-invalid-atomic-ordering-update.rs:142:40
+  --> $DIR/lint-invalid-atomic-ordering-update.rs:140:40
    |
 LL |     let _ = x.update(Ordering::SeqCst, Ordering::Release, |old| old + 1);
    |                                        ^^^^^^^^^^^^^^^^^ invalid failure ordering

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`2`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:73:47`
	`2`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:71:47`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, \|old\| Some(old + 1));`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`@@ -8,231 +8,231 @@ LL \| let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, \|old\| Some(`
`8`	`8`	= note: `#[deny(invalid_atomic_ordering)]` on by default
`9`	`9`
`10`	`10`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`11`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:75:45`
	`11`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:73:45`
`12`	`12`	`\|`
`13`	`13`	`LL \| let _ = x.try_update(Ordering::Relaxed, Ordering::AcqRel, \|old\| Some(old + 1));`
`14`	`14`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`15`	`15`	`\|`
`16`	`16`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`17`	`17`
`18`	`18`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`19`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:77:41`
	`19`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:75:41`
`20`	`20`	`\|`
`21`	`21`	`LL \| let _ = x.update(Ordering::Relaxed, Ordering::AcqRel, \|old\| old + 1);`
`22`	`22`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`23`	`23`	`\|`
`24`	`24`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`25`	`25`
`26`	`26`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`27`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:80:47`
	`27`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:78:47`
`28`	`28`	`\|`
`29`	`29`	`LL \| let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, \|old\| Some(old + 1));`
`30`	`30`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`31`	`31`	`\|`
`32`	`32`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`33`	`33`
`34`	`34`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`35`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:82:45`
	`35`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:80:45`
`36`	`36`	`\|`
`37`	`37`	`LL \| let _ = x.try_update(Ordering::Acquire, Ordering::AcqRel, \|old\| Some(old + 1));`
`38`	`38`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`39`	`39`	`\|`
`40`	`40`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`41`	`41`
`42`	`42`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`43`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:84:41`
	`43`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:82:41`
`44`	`44`	`\|`
`45`	`45`	`LL \| let _ = x.update(Ordering::Acquire, Ordering::AcqRel, \|old\| old + 1);`
`46`	`46`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`47`	`47`	`\|`
`48`	`48`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`49`	`49`
`50`	`50`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`51`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:87:47`
	`51`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:85:47`
`52`	`52`	`\|`
`53`	`53`	`LL \| let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, \|old\| Some(old + 1));`
`54`	`54`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`55`	`55`	`\|`
`56`	`56`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`57`	`57`
`58`	`58`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`59`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:89:45`
	`59`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:87:45`
`60`	`60`	`\|`
`61`	`61`	`LL \| let _ = x.try_update(Ordering::Release, Ordering::AcqRel, \|old\| Some(old + 1));`
`62`	`62`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`63`	`63`	`\|`
`64`	`64`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`65`	`65`
`66`	`66`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`67`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:91:41`
	`67`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:89:41`
`68`	`68`	`\|`
`69`	`69`	`LL \| let _ = x.update(Ordering::Release, Ordering::AcqRel, \|old\| old + 1);`
`70`	`70`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`71`	`71`	`\|`
`72`	`72`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`73`	`73`
`74`	`74`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`75`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:94:46`
	`75`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:92:46`
`76`	`76`	`\|`
`77`	`77`	`LL \| let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, \|old\| Some(old + 1));`
`78`	`78`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`79`	`79`	`\|`
`80`	`80`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`81`	`81`
`82`	`82`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`83`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:96:44`
	`83`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:94:44`
`84`	`84`	`\|`
`85`	`85`	`LL \| let _ = x.try_update(Ordering::AcqRel, Ordering::AcqRel, \|old\| Some(old + 1));`
`86`	`86`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`87`	`87`	`\|`
`88`	`88`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`89`	`89`
`90`	`90`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`91`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:98:40`
	`91`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:96:40`
`92`	`92`	`\|`
`93`	`93`	`LL \| let _ = x.update(Ordering::AcqRel, Ordering::AcqRel, \|old\| old + 1);`
`94`	`94`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`95`	`95`	`\|`
`96`	`96`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`97`	`97`
`98`	`98`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`99`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:101:46`
	`99`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:99:46`
`100`	`100`	`\|`
`101`	`101`	`LL \| let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, \|old\| Some(old + 1));`
`102`	`102`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`103`	`103`	`\|`
`104`	`104`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`105`	`105`
`106`	`106`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`107`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:103:44`
	`107`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:101:44`
`108`	`108`	`\|`
`109`	`109`	`LL \| let _ = x.try_update(Ordering::SeqCst, Ordering::AcqRel, \|old\| Some(old + 1));`
`110`	`110`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`111`	`111`	`\|`
`112`	`112`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`113`	`113`
`114`	`114`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`115`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:105:40`
	`115`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:103:40`
`116`	`116`	`\|`
`117`	`117`	`LL \| let _ = x.update(Ordering::SeqCst, Ordering::AcqRel, \|old\| old + 1);`
`118`	`118`	`\| ^^^^^^^^^^^^^^^^ invalid failure ordering`
`119`	`119`	`\|`
`120`	`120`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`121`	`121`
`122`	`122`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`123`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:110:47`
	`123`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:108:47`
`124`	`124`	`\|`
`125`	`125`	`LL \| let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, \|old\| Some(old + 1));`
`126`	`126`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`127`	`127`	`\|`
`128`	`128`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`129`	`129`
`130`	`130`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`131`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:112:45`
	`131`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:110:45`
`132`	`132`	`\|`
`133`	`133`	`LL \| let _ = x.try_update(Ordering::Relaxed, Ordering::Release, \|old\| Some(old + 1));`
`134`	`134`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`135`	`135`	`\|`
`136`	`136`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`137`	`137`
`138`	`138`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`139`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:114:41`
	`139`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:112:41`
`140`	`140`	`\|`
`141`	`141`	`LL \| let _ = x.update(Ordering::Relaxed, Ordering::Release, \|old\| old + 1);`
`142`	`142`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`143`	`143`	`\|`
`144`	`144`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`145`	`145`
`146`	`146`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`147`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:117:47`
	`147`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:115:47`
`148`	`148`	`\|`
`149`	`149`	`LL \| let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, \|old\| Some(old + 1));`
`150`	`150`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`151`	`151`	`\|`
`152`	`152`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`153`	`153`
`154`	`154`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`155`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:119:45`
	`155`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:117:45`
`156`	`156`	`\|`
`157`	`157`	`LL \| let _ = x.try_update(Ordering::Acquire, Ordering::Release, \|old\| Some(old + 1));`
`158`	`158`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`159`	`159`	`\|`
`160`	`160`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`161`	`161`
`162`	`162`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`163`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:121:41`
	`163`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:119:41`
`164`	`164`	`\|`
`165`	`165`	`LL \| let _ = x.update(Ordering::Acquire, Ordering::Release, \|old\| old + 1);`
`166`	`166`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`167`	`167`	`\|`
`168`	`168`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`169`	`169`
`170`	`170`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`171`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:124:47`
	`171`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:122:47`
`172`	`172`	`\|`
`173`	`173`	`LL \| let _ = x.fetch_update(Ordering::Release, Ordering::Release, \|old\| Some(old + 1));`
`174`	`174`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`175`	`175`	`\|`
`176`	`176`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`177`	`177`
`178`	`178`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`179`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:126:45`
	`179`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:124:45`
`180`	`180`	`\|`
`181`	`181`	`LL \| let _ = x.try_update(Ordering::Release, Ordering::Release, \|old\| Some(old + 1));`
`182`	`182`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`183`	`183`	`\|`
`184`	`184`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`185`	`185`
`186`	`186`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`187`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:128:41`
	`187`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:126:41`
`188`	`188`	`\|`
`189`	`189`	`LL \| let _ = x.update(Ordering::Release, Ordering::Release, \|old\| old + 1);`
`190`	`190`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`191`	`191`	`\|`
`192`	`192`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`193`	`193`
`194`	`194`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`195`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:131:46`
	`195`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:129:46`
`196`	`196`	`\|`
`197`	`197`	`LL \| let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, \|old\| Some(old + 1));`
`198`	`198`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`199`	`199`	`\|`
`200`	`200`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`201`	`201`
`202`	`202`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`203`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:133:44`
	`203`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:131:44`
`204`	`204`	`\|`
`205`	`205`	`LL \| let _ = x.try_update(Ordering::AcqRel, Ordering::Release, \|old\| Some(old + 1));`
`206`	`206`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`207`	`207`	`\|`
`208`	`208`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`209`	`209`
`210`	`210`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`211`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:135:40`
	`211`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:133:40`
`212`	`212`	`\|`
`213`	`213`	`LL \| let _ = x.update(Ordering::AcqRel, Ordering::Release, \|old\| old + 1);`
`214`	`214`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`215`	`215`	`\|`
`216`	`216`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`217`	`217`
`218`	`218`	error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
`219`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:138:46`
	`219`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:136:46`
`220`	`220`	`\|`
`221`	`221`	`LL \| let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, \|old\| Some(old + 1));`
`222`	`222`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`223`	`223`	`\|`
`224`	`224`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`225`	`225`
`226`	`226`	error: `try_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `try_update` does not result in a write
`227`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:140:44`
	`227`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:138:44`
`228`	`228`	`\|`
`229`	`229`	`LL \| let _ = x.try_update(Ordering::SeqCst, Ordering::Release, \|old\| Some(old + 1));`
`230`	`230`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`
`231`	`231`	`\|`
`232`	`232`	= help: consider using `Acquire` or `Relaxed` failure ordering instead
`233`	`233`
`234`	`234`	error: `update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `update` does not result in a write
`235`		`- --> $DIR/lint-invalid-atomic-ordering-update.rs:142:40`
	`235`	`+ --> $DIR/lint-invalid-atomic-ordering-update.rs:140:40`
`236`	`236`	`\|`
`237`	`237`	`LL \| let _ = x.update(Ordering::SeqCst, Ordering::Release, \|old\| old + 1);`
`238`	`238`	`\| ^^^^^^^^^^^^^^^^^ invalid failure ordering`