invalid_atomic_ordering: also lint update & try_update

Author: GrigorenkoPV

compiler/rustc_lint/src/types.rs

@@ -1022,7 +1022,8 @@ declare_lint! {
     ///
     /// - Passing `Ordering::Release` or `Ordering::AcqRel` as the failure
     ///   ordering for any of `AtomicType::compare_exchange`,
-    ///   `AtomicType::compare_exchange_weak`, or `AtomicType::fetch_update`.
+    ///   `AtomicType::compare_exchange_weak`, `AtomicType::update`, or
+    ///   `AtomicType::try_update`.
     INVALID_ATOMIC_ORDERING,
     Deny,
     "usage of invalid atomic ordering in atomic operations and memory fences"
@@ -1118,13 +1119,19 @@ impl InvalidAtomicOrdering {
         let Some((method, args)) = Self::inherent_atomic_method_call(
             cx,
             expr,
-            &[sym::fetch_update, sym::compare_exchange, sym::compare_exchange_weak],
+            &[
+                sym::update,
+                sym::try_update,
+                sym::fetch_update,
+                sym::compare_exchange,
+                sym::compare_exchange_weak,
+            ],
         ) else {
             return;
         };
 
         let fail_order_arg = match method {
-            sym::fetch_update => &args[1],
+            sym::update | sym::try_update | sym::fetch_update => &args[1],
             sym::compare_exchange | sym::compare_exchange_weak => &args[3],
             _ => return,
         };

compiler/rustc_span/src/symbol.rs

@@ -2273,6 +2273,7 @@ symbols! {
         try_from_fn,
         try_into,
         try_trait_v2,
+        try_update,
         tt,
         tuple,
         tuple_indexing,
@@ -2390,6 +2391,7 @@ symbols! {
         unwrap,
         unwrap_binder,
         unwrap_or,
+        update,
         use_cloned,
         use_extern_macros,
         use_nested_groups,

tests/ui/lint/lint-invalid-atomic-ordering-fetch-update.rs

@@ -7,43 +7,136 @@ fn main() {
 
     // Allowed ordering combos
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Relaxed, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.update(Ordering::Relaxed, Ordering::Relaxed, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.update(Ordering::Relaxed, Ordering::Acquire, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.update(Ordering::Relaxed, Ordering::SeqCst, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Acquire, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Acquire, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.update(Ordering::Acquire, Ordering::Relaxed, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Acquire, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Acquire, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.update(Ordering::Acquire, Ordering::Acquire, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.update(Ordering::Acquire, Ordering::SeqCst, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Release, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Release, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.update(Ordering::Release, Ordering::Relaxed, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.update(Ordering::Release, Ordering::Acquire, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.update(Ordering::Release, Ordering::SeqCst, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::AcqRel, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.update(Ordering::AcqRel, Ordering::Relaxed, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::AcqRel, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.update(Ordering::AcqRel, Ordering::Acquire, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.update(Ordering::AcqRel, Ordering::SeqCst, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::SeqCst, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.update(Ordering::SeqCst, Ordering::Relaxed, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::SeqCst, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.update(Ordering::SeqCst, Ordering::Acquire, |old| old + 1);
+
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.try_update(Ordering::SeqCst, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.update(Ordering::SeqCst, Ordering::SeqCst, |old| old + 1);
 
     // AcqRel is always forbidden as a failure ordering
+
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Relaxed, Ordering::AcqRel, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Acquire, Ordering::AcqRel, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Release, Ordering::AcqRel, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::AcqRel, Ordering::AcqRel, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::SeqCst, Ordering::AcqRel, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
 
     // Release is always forbidden as a failure ordering
+
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Relaxed, Ordering::Release, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Acquire, Ordering::Release, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::Release, Ordering::Release, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.try_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::AcqRel, Ordering::Release, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
+
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
     //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
-
+    let _ = x.try_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR `try_update`'s failure ordering may not be `Release` or `AcqRel`
+    let _ = x.update(Ordering::SeqCst, Ordering::Release, |old| old + 1);
+    //~^ ERROR `update`'s failure ordering may not be `Release` or `AcqRel`
 }