Fixed the suggestion, added stderr and fixed files

Author: theo-lw

clippy_lints/src/map_identity.rs

@@ -8,20 +8,20 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_hir::*;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for instances `iterator.map(f)` where `f` is the identity function.
+    /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
     ///
-    /// **Why is this bad?** It can be written more concisely as `iterator`, without the call to `map`.
+    /// **Why is this bad?** It can be written more concisely without the call to `map`.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// let x = [1, 2, 3].map(|x| x).
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// let x = 
     /// ```
     pub MAP_IDENTITY,
     style,
@@ -32,22 +32,21 @@ declare_lint_pass!(MapIdentity => [MAP_IDENTITY]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MapIdentity {
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-        // println!("start");
         if expr.span.from_expansion() {
             return;
         }
 
         if_chain! {
-            if let Some(func) = get_map_argument(cx, expr);
+            if let Some([caller, func]) = get_map_argument(cx, expr);
             if let Some(body) = get_body(cx, func);
             if is_identity_function(cx, body);
             then {
                 span_lint_and_sugg(
                     cx,
                     MAP_IDENTITY,
-                    expr.span,
-                    "Unnecessary map of the identity function",
-                    "Remove the `map` call",
+                    expr.span.trim_start(caller.span).unwrap(),
+                    "unnecessary map of the identity function",
+                    "remove the call to `map`",
                     String::new(),
                     Applicability::MachineApplicable
                 )
@@ -57,9 +56,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MapIdentity {
 }
 
 
-/// Returns the function passed into iterator.map() if the expression is a method call to
-/// iterator.map(). Otherwise, returns None.
-fn get_map_argument<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
+/// Returns the arguments passed into map() if the expression is a method call to
+/// map(). Otherwise, returns None.
+fn get_map_argument<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args) = expr.kind;
         if args.len() == 2 && method.ident.as_str() == "map";
@@ -68,7 +67,7 @@ fn get_map_argument<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<
             || is_type_diagnostic_item(cx, caller_ty, sym!(result_type))
             || is_type_diagnostic_item(cx, caller_ty, sym!(option_type));
         then {
-            Some(&args[1])
+            Some(args)
         } else {
             None
         }

tests/ui/map_identity.fixed

@@ -0,0 +1,23 @@
+// run-rustfix
+#![warn(clippy::map_identity)]
+#![allow(clippy::needless_return)]
+
+fn main() {
+    let x: [u16; 3] = [1, 2, 3];
+    // should lint
+    let _: Vec<_> = x.iter().collect();
+    let _: Vec<_> = x.iter().collect();
+    let _: Option<u8> = Some(3);
+    // should not lint
+    let _: Vec<_> = x.iter().map(|x| 2*x).collect();
+    let _: Vec<_> = x.iter().map(not_identity).collect();
+}
+
+#[allow(dead_code)]
+fn identity(x: &u16) -> &u16 {
+    return x;
+}
+
+fn not_identity(x: &u16) -> u16 {
+    *x
+}

tests/ui/map_identity.rs

@@ -1,3 +1,4 @@
+// run-rustfix
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return)]
 
@@ -12,6 +13,7 @@ fn main() {
     let _: Vec<_> = x.iter().map(not_identity).collect();
 }
 
+#[allow(dead_code)]
 fn identity(x: &u16) -> &u16 {
     return x;
 }

tests/ui/map_identity.stderr

@@ -0,0 +1,22 @@
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:8:29
+   |
+LL |     let _: Vec<_> = x.iter().map(|x| { return x }).collect();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
+   |
+   = note: `-D clippy::map-identity` implied by `-D warnings`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:9:29
+   |
+LL |     let _: Vec<_> = x.iter().map(identity).collect();
+   |                             ^^^^^^^^^^^^^^ help: remove the call to `map`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:10:32
+   |
+LL |     let _: Option<u8> = Some(3).map(|x| x);
+   |                                ^^^^^^^^^^^ help: remove the call to `map`
+
+error: aborting due to 3 previous errors
+