clean-up

Author: ada4a

clippy_lints/src/methods/mod.rs

@@ -5360,7 +5360,7 @@ impl Methods {
                     }
                 },
                 (sym::lock, []) => {
-                    mut_mutex_lock::check(cx, expr, recv, span);
+                    mut_mutex_lock::check(cx, recv, span);
                 },
                 (name @ (sym::map | sym::map_err), [m_arg]) => {
                     if name == sym::map {

clippy_lints/src/methods/mut_mutex_lock.rs

@@ -9,12 +9,12 @@ use rustc_span::{Span, sym};
 
 use super::MUT_MUTEX_LOCK;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
     if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut))
-        && let (_, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(recv))
-        && let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id)
-        && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id)
-        && cx.tcx.type_of(impl_id).is_diag_item(cx, sym::Mutex)
+        // NOTE: the reason we don't use `expr_ty_adjusted` here is that a call to `Mutex::lock` by itself
+        // adjusts the receiver to be `&Mutex`
+        && let (recv_ty, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(recv))
+        && recv_ty.is_diag_item(cx, sym::Mutex)
     {
         span_lint_and_sugg(
             cx,

clippy_utils/src/lib.rs

@@ -459,10 +459,9 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, owner: OwnerId) -> Opti
 /// This method will return tuple of projection stack and root of the expression,
 /// used in `can_mut_borrow_both`.
 ///
-/// For example, if `e` represents the `v[0].a.b[x]`
-/// this method will return a tuple, composed of a `Vec`
-/// containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
-/// and an `Expr` for root of them, `v`
+/// For example, if `e` represents the `v[0].a.b[x]` this method will return a tuple, composed of:
+/// - a `Vec` containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
+/// - and an `Expr` for root of them, `v`
 fn projection_stack<'a, 'hir>(mut e: &'a Expr<'hir>) -> (Vec<&'a Expr<'hir>>, &'a Expr<'hir>) {
     let mut result = vec![];
     let root = loop {
@@ -488,7 +487,8 @@ pub fn expr_custom_deref_adjustment(cx: &LateContext<'_>, e: &Expr<'_>) -> Optio
             Adjust::Deref(None) => None,
             _ => Some(None),
         })
-        .and_then(|x| x)
+        // if there were no adjustments to begin with, trivially none of them are of the custom-deref kind
+        .unwrap_or(None)
 }
 
 /// Checks if two expressions can be mutably borrowed simultaneously

tests/ui/mut_mutex_lock.fixed

@@ -1,4 +1,3 @@
-#![allow(dead_code, unused_mut)]
 #![warn(clippy::mut_mutex_lock)]
 
 use std::sync::{Arc, Mutex};

tests/ui/mut_mutex_lock.rs

@@ -1,4 +1,3 @@
-#![allow(dead_code, unused_mut)]
 #![warn(clippy::mut_mutex_lock)]
 
 use std::sync::{Arc, Mutex};

tests/ui/mut_mutex_lock.stderr

@@ -1,5 +1,5 @@
 error: calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference
-  --> tests/ui/mut_mutex_lock.rs:10:33
+  --> tests/ui/mut_mutex_lock.rs:9:33
    |
 LL |     let mut value = value_mutex.lock().unwrap();
    |                                 ^^^^ help: change this to: `get_mut`
@@ -8,7 +8,7 @@ LL |     let mut value = value_mutex.lock().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::mut_mutex_lock)]`
 
 error: calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference
-  --> tests/ui/mut_mutex_lock.rs:16:43
+  --> tests/ui/mut_mutex_lock.rs:15:43
    |
 LL |     let mut value = mut_ref_mut_ref_mutex.lock().unwrap();
    |                                           ^^^^ help: change this to: `get_mut`