suggest replacing Mutex::new with AtomicX::new

Author: ada4a

clippy_lints/src/mutex_atomic.rs

@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeDef;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::ty_from_hir_ty;
-use rustc_errors::Diag;
-use rustc_hir::{Expr, Item, ItemKind, LetStmt};
+use rustc_errors::{Applicability, Diag};
+use rustc_hir::{Expr, ExprKind, Item, ItemKind, LetStmt, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, IntTy, Ty, UintTy};
 use rustc_session::declare_lint_pass;
@@ -120,7 +121,19 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, ty: Ty<'tcx>) {
     {
         let msg = "using a `Mutex` where an atomic would do";
         let diag = |diag: &mut Diag<'_, _>| {
-            diag.help(format!("consider using an `{atomic_name}` instead"));
+            // if `expr = Mutex::new(arg)`, we can try emitting a suggestion
+            if let ExprKind::Call(qpath, [arg]) = expr.kind
+                && let ExprKind::Path(QPath::TypeRelative(_mutex, new)) = qpath.kind
+                && new.ident.name == sym::new
+            {
+                let mut applicability = Applicability::MaybeIncorrect;
+                let arg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability);
+
+                let suggs = vec![(expr.span, format!("std::sync::atomic::{atomic_name}::new({arg})"))];
+                diag.multipart_suggestion("try", suggs, applicability);
+            } else {
+                diag.help(format!("consider using an `{atomic_name}` instead"));
+            }
             diag.help("if you just want the locking behavior and not the internal type, consider using `Mutex<()>`");
         };
         match *mutex_param.kind() {

tests/ui/mutex_atomic.rs

@@ -1,3 +1,4 @@
+//@no-rustfix
 #![warn(clippy::mutex_integer)]
 #![warn(clippy::mutex_atomic)]
 #![allow(clippy::borrow_as_ptr)]
@@ -48,11 +49,11 @@ fn main() {
     }
 }
 
-static MTX: Mutex<u32> = Mutex::new(0);
-//~^ mutex_integer
-
 // don't lint on _use_, only declaration
 fn issue13378() {
+    static MTX: Mutex<u32> = Mutex::new(0);
+    //~^ mutex_integer
+
     let mut guard = MTX.lock().unwrap();
     *guard += 1;
 

tests/ui/mutex_atomic.stderr

@@ -1,126 +1,113 @@
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:8:13
+  --> tests/ui/mutex_atomic.rs:9:13
    |
 LL |     let _ = Mutex::new(true);
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicBool::new(true)`
    |
-   = help: consider using an `AtomicBool` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
    = note: `-D clippy::mutex-atomic` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mutex_atomic)]`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:11:13
+  --> tests/ui/mutex_atomic.rs:12:13
    |
 LL |     let _ = Mutex::new(5usize);
-   |             ^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicUsize::new(5usize)`
    |
-   = help: consider using an `AtomicUsize` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:14:13
+  --> tests/ui/mutex_atomic.rs:15:13
    |
 LL |     let _ = Mutex::new(9isize);
-   |             ^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicIsize::new(9isize)`
    |
-   = help: consider using an `AtomicIsize` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:18:13
+  --> tests/ui/mutex_atomic.rs:19:13
    |
 LL |     let _ = Mutex::new(&x as *const u32);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicPtr::new(&x as *const u32)`
    |
-   = help: consider using an `AtomicPtr` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:21:13
+  --> tests/ui/mutex_atomic.rs:22:13
    |
 LL |     let _ = Mutex::new(&mut x as *mut u32);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicPtr::new(&mut x as *mut u32)`
    |
-   = help: consider using an `AtomicPtr` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:24:13
+  --> tests/ui/mutex_atomic.rs:25:13
    |
 LL |     let _ = Mutex::new(0u32);
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicU32::new(0u32)`
    |
-   = help: consider using an `AtomicU32` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
    = note: `-D clippy::mutex-integer` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mutex_integer)]`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:27:13
+  --> tests/ui/mutex_atomic.rs:28:13
    |
 LL |     let _ = Mutex::new(0i32);
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicI32::new(0i32)`
    |
-   = help: consider using an `AtomicI32` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:31:13
+  --> tests/ui/mutex_atomic.rs:32:13
    |
 LL |     let _ = Mutex::new(0u8);
-   |             ^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicU8::new(0u8)`
    |
-   = help: consider using an `AtomicU8` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:34:13
+  --> tests/ui/mutex_atomic.rs:35:13
    |
 LL |     let _ = Mutex::new(0i16);
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicI16::new(0i16)`
    |
-   = help: consider using an `AtomicI16` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:37:25
+  --> tests/ui/mutex_atomic.rs:38:25
    |
 LL |     let _x: Mutex<i8> = Mutex::new(0);
-   |                         ^^^^^^^^^^^^^
+   |                         ^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicI8::new(0)`
    |
-   = help: consider using an `AtomicI8` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:41:13
+  --> tests/ui/mutex_atomic.rs:42:13
    |
 LL |     let _ = Mutex::new(X);
-   |             ^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicI64::new(X)`
    |
-   = help: consider using an `AtomicI64` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:51:26
+  --> tests/ui/mutex_atomic.rs:54:30
    |
-LL | static MTX: Mutex<u32> = Mutex::new(0);
-   |                          ^^^^^^^^^^^^^
+LL |     static MTX: Mutex<u32> = Mutex::new(0);
+   |                              ^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicU32::new(0)`
    |
-   = help: consider using an `AtomicU32` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:59:15
+  --> tests/ui/mutex_atomic.rs:60:15
    |
 LL |     let mtx = Mutex::new(0);
-   |               ^^^^^^^^^^^^^
+   |               ^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicI32::new(0)`
    |
-   = help: consider using an `AtomicI32` instead
    = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
 
 error: using a `Mutex` where an atomic would do
-  --> tests/ui/mutex_atomic.rs:63:22
+  --> tests/ui/mutex_atomic.rs:64:22
    |
 LL |     let reassigned = mtx;
    |                      ^^^