chore

Author: tamaroning

clippy_lints/src/methods/map_then_identity_transformer.rs

@@ -19,8 +19,8 @@ pub(super) fn check<'tcx>(
     if_chain!(
         if let ExprKind::Closure(_, _, meth1_clos_body_id, _, _) = &meth1_clos.kind;
         if let ExprKind::Closure(_, _, meth2_clos_body_id, _, _) = &meth2_clos.kind;
-        if let Some(_) = refd_param_span(cx, meth1_clos_body_id);
-        if let Some(refd_param_span) = refd_param_span(cx, meth2_clos_body_id);
+        if let Some(_) = refd_param_span(cx, *meth1_clos_body_id);
+        if let Some(refd_param_span) = refd_param_span(cx, *meth2_clos_body_id);
         then {
             let meth1_clos_val = &cx.tcx.hir().body(*meth1_clos_body_id).value;
 
@@ -37,18 +37,18 @@ pub(super) fn check<'tcx>(
                 },
             );
         }
-    )
+    );
 }
 
 // On a given closure `|.., x| y`, checks if `x` is referenced just exactly once in `y` and returns
 // the span of `x`
-fn refd_param_span<'tcx>(cx: &LateContext<'tcx>, clos_body_id: &BodyId) -> Option<Span> {
+fn refd_param_span<'tcx>(cx: &LateContext<'tcx>, clos_body_id: BodyId) -> Option<Span> {
+    let clos_body = cx.tcx.hir().body(clos_body_id);
     if_chain! {
-        let clos_body = cx.tcx.hir().body(*clos_body_id);
         if let [.., clos_param] = clos_body.params;
         if let PatKind::Binding(_, clos_param_id, _, _) = clos_param.pat.kind;
-        let clos_val = &clos_body.value;
         then {
+            let clos_val = &clos_body.value;
             let mut count = 0;
             let mut span = None;
             expr_visitor(cx, |expr| {

clippy_lints/src/methods/mod.rs

@@ -1959,20 +1959,20 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds _.f(_).g(_) where the method calls may be collapsed together and where f and g are transformers: map, all, any, find, etc.
+    /// Finds `_.map(_).f(_)` where the method calls may be collapsed together and where f is a transformer: `map`, `all`, `any`, `find`, etc.
     ///
     /// ### Why is this bad?
     /// It is unnecessarily verbose and complex.
     ///
     /// ### Example
     /// ```rust
     /// let iter = vec![1, 2, 3].into_iter();
-    /// let _ = iter.map(|x| foo(x)).flat_map(|x| bar(x));
+    /// let _ = iter.map(|x| x * 2).map(|x| x + 1);
     /// ```
     /// Use instead:
     /// ```rust
     /// let iter = vec![1, 2, 3].into_iter();
-    /// let _ = iter.flat_map(|x| bar(foo(x)));
+    /// let _ = iter.map(|x| x * 2 + 1);
     /// ```
     #[clippy::version = "1.60.0"]
     pub MAP_THEN_IDENTITY_TRANSFORMER,
@@ -2062,6 +2062,7 @@ impl_lint_pass!(Methods => [
     MANUAL_SPLIT_ONCE,
     NEEDLESS_SPLITN,
     UNNECESSARY_TO_OWNED,
+    MAP_THEN_IDENTITY_TRANSFORMER,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2384,7 +2385,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                         },
                         ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
                         (name2 @ "map", [arg2]) => {
-                            map_then_identity_transformer::check(cx, span2, name2, arg2, name, m_arg)
+                            map_then_identity_transformer::check(cx, span2, name2, arg2, name, m_arg);
                         },
                         _ => {},
                     }