Added tests for map_err, ignored map_err lint on drop_ref tests

Ricky · Ricky · commit 202a80c92741 · 2020-09-01T16:59:37.000-04:00
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
@@ -1,6 +1,6 @@
 use crate::utils::span_lint_and_sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, CaptureBy, PatKind, QPath};
+use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     ///    Ignore
     ///}
     ///fn main() -> Result<(), Errors> {
-    ///    
+    ///
     ///    let x = u32::try_from(-123_i32);
     ///
     ///    println!("{:?}", x.map_err(|_| Errors::Ignore));
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     ///    WithContext(TryFromIntError)
     ///}
     ///fn main() -> Result<(), Errors> {
-    ///    
+    ///
     ///    let x = u32::try_from(-123_i32);
     ///
     ///    println!("{:?}", x.map_err(|e| Errors::WithContext(e)));
@@ -48,34 +48,42 @@ declare_clippy_lint! {
 declare_lint_pass!(MapErrIgnore => [MAP_ERR_IGNORE]);
 
 impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
-    // do not try to lint if this is from a macro or desugaring 
+    // do not try to lint if this is from a macro or desugaring
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
         if e.span.from_expansion() {
             return;
         }
 
         // check if this is a method call (e.g. x.foo())
         if let ExprKind::MethodCall(ref method, _t_span, ref args, _) = e.kind {
-            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1] Enum::Variant[2]))
+            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
+            // Enum::Variant[2]))
             if method.ident.as_str() == "map_err" && args.len() == 2 {
                 // make sure the first argument is a closure, and grab the CaptureRef, body_id, and body_span fields
-                if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {  
+                if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {
                     // check if this is by Reference (meaning there's no move statement)
-                    if capture == CaptureBy::Ref { 
-                        // Get the closure body to check the parameters and values 
+                    if capture == CaptureBy::Ref {
+                        // Get the closure body to check the parameters and values
                         let closure_body = cx.tcx.hir().body(body_id);
                         // make sure there's only one parameter (`|_|`)
-                        if closure_body.params.len() == 1 {          
-                            // make sure that parameter is the wild token (`_`)                  
+                        if closure_body.params.len() == 1 {
+                            // make sure that parameter is the wild token (`_`)
                             if let PatKind::Wild = closure_body.params[0].pat.kind {
-                                // Check the value of the closure to see if we can build the enum we are throwing away the error for
-                                // make sure this is a Path
+                                // Check the value of the closure to see if we can build the enum we are throwing away
+                                // the error for make sure this is a Path
                                 if let ExprKind::Path(q_path) = &closure_body.value.kind {
                                     // this should be a resolved path, only keep the path field
                                     if let QPath::Resolved(_, path) = q_path {
-                                        // finally get the idents for each path segment collect them as a string and join them with the path separator ("::"")
-                                        let closure_fold: String = path.segments.iter().map(|x| x.ident.as_str().to_string()).collect::<Vec<String>>().join("::");
-                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking the error and encapsulating it in the enum 
+                                        // finally get the idents for each path segment collect them as a string and
+                                        // join them with the path separator ("::"")
+                                        let closure_fold: String = path
+                                            .segments
+                                            .iter()
+                                            .map(|x| x.ident.as_str().to_string())
+                                            .collect::<Vec<String>>()
+                                            .join("::");
+                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking
+                                        // the error and encapsulating it in the enum
                                         span_lint_and_sugg(
                                             cx,
                                             MAP_ERR_IGNORE,
@@ -84,10 +92,11 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                             "Allow the error enum to encapsulate the original error",
                                             format!("|e| {}(e)", closure_fold),
                                             Applicability::HasPlaceholders,
-                                        ); 
+                                        );
                                     }
                                 } else {
-                                    //If we cannot build the enum in a human readable way just suggest not throwing way the error
+                                    //If we cannot build the enum in a human readable way just suggest not throwing way
+                                    // the error
                                     span_lint_and_sugg(
                                         cx,
                                         MAP_ERR_IGNORE,
@@ -96,13 +105,13 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                         "Allow the error enum to encapsulate the original error",
                                         "|e|".to_string(),
                                         Applicability::HasPlaceholders,
-                                    ); 
+                                    );
                                 }
                             }
                         }
-                    }  
+                    }
                 }
             }
         }
     }
-}
+}
diff --git a/tests/ui/drop_ref.rs b/tests/ui/drop_ref.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::drop_ref)]
 #![allow(clippy::toplevel_ref_arg)]
+#![allow(clippy::map_err_ignore)]
 
 use std::mem::drop;
 
diff --git a/tests/ui/drop_ref.stderr b/tests/ui/drop_ref.stderr
@@ -1,108 +1,108 @@
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:9:5
+  --> $DIR/drop_ref.rs:10:5
    |
 LL |     drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::drop-ref` implied by `-D warnings`
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:9:10
+  --> $DIR/drop_ref.rs:10:10
    |
 LL |     drop(&SomeStruct);
    |          ^^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:12:5
+  --> $DIR/drop_ref.rs:13:5
    |
 LL |     drop(&owned1);
    |     ^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:12:10
+  --> $DIR/drop_ref.rs:13:10
    |
 LL |     drop(&owned1);
    |          ^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:13:5
+  --> $DIR/drop_ref.rs:14:5
    |
 LL |     drop(&&owned1);
    |     ^^^^^^^^^^^^^^
    |
 note: argument has type `&&SomeStruct`
-  --> $DIR/drop_ref.rs:13:10
+  --> $DIR/drop_ref.rs:14:10
    |
 LL |     drop(&&owned1);
    |          ^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:14:5
+  --> $DIR/drop_ref.rs:15:5
    |
 LL |     drop(&mut owned1);
    |     ^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:14:10
+  --> $DIR/drop_ref.rs:15:10
    |
 LL |     drop(&mut owned1);
    |          ^^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:18:5
+  --> $DIR/drop_ref.rs:19:5
    |
 LL |     drop(reference1);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:18:10
+  --> $DIR/drop_ref.rs:19:10
    |
 LL |     drop(reference1);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:21:5
+  --> $DIR/drop_ref.rs:22:5
    |
 LL |     drop(reference2);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:21:10
+  --> $DIR/drop_ref.rs:22:10
    |
 LL |     drop(reference2);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:24:5
+  --> $DIR/drop_ref.rs:25:5
    |
 LL |     drop(reference3);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:24:10
+  --> $DIR/drop_ref.rs:25:10
    |
 LL |     drop(reference3);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:29:5
+  --> $DIR/drop_ref.rs:30:5
    |
 LL |     drop(&val);
    |     ^^^^^^^^^^
    |
 note: argument has type `&T`
-  --> $DIR/drop_ref.rs:29:10
+  --> $DIR/drop_ref.rs:30:10
    |
 LL |     drop(&val);
    |          ^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:37:5
+  --> $DIR/drop_ref.rs:38:5
    |
 LL |     std::mem::drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:37:20
+  --> $DIR/drop_ref.rs:38:20
    |
 LL |     std::mem::drop(&SomeStruct);
    |                    ^^^^^^^^^^^
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
@@ -0,0 +1,24 @@
+use std::convert::TryFrom;
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug)]
+enum Errors {
+    Ignored,
+}
+
+impl Error for Errors {}
+
+impl fmt::Display for Errors {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Error")
+    }
+}
+
+fn main() -> Result<(), Errors> {
+    let x = u32::try_from(-123_i32);
+
+    println!("{:?}", x.map_err(|_| Errors::Ignored));
+
+    Ok(())
+}
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
@@ -0,0 +1,10 @@
+error: `map_err` has thrown away the original error
+  --> $DIR/map_err.rs:21:32
+   |
+LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
+   |                                ^^^ help: Allow the error enum to encapsulate the original error: `|e| Errors::Ignored(e)`
+   |
+   = note: `-D clippy::map-err-ignore` implied by `-D warnings`
+
+error: aborting due to previous error
+

Original file line number	Diff line number	Diff line change
`@@ -1,108 +1,108 @@`
`1`	`1`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`2`		`- --> $DIR/drop_ref.rs:9:5`
	`2`	`+ --> $DIR/drop_ref.rs:10:5`
`3`	`3`	`\|`
`4`	`4`	`LL \| drop(&SomeStruct);`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::drop-ref` implied by `-D warnings`
`8`	`8`	note: argument has type `&SomeStruct`
`9`		`- --> $DIR/drop_ref.rs:9:10`
	`9`	`+ --> $DIR/drop_ref.rs:10:10`
`10`	`10`	`\|`
`11`	`11`	`LL \| drop(&SomeStruct);`
`12`	`12`	`\| ^^^^^^^^^^^`
`13`	`13`
`14`	`14`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`15`		`- --> $DIR/drop_ref.rs:12:5`
	`15`	`+ --> $DIR/drop_ref.rs:13:5`
`16`	`16`	`\|`
`17`	`17`	`LL \| drop(&owned1);`
`18`	`18`	`\| ^^^^^^^^^^^^^`
`19`	`19`	`\|`
`20`	`20`	note: argument has type `&SomeStruct`
`21`		`- --> $DIR/drop_ref.rs:12:10`
	`21`	`+ --> $DIR/drop_ref.rs:13:10`
`22`	`22`	`\|`
`23`	`23`	`LL \| drop(&owned1);`
`24`	`24`	`\| ^^^^^^^`
`25`	`25`
`26`	`26`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`27`		`- --> $DIR/drop_ref.rs:13:5`
	`27`	`+ --> $DIR/drop_ref.rs:14:5`
`28`	`28`	`\|`
`29`	`29`	`LL \| drop(&&owned1);`
`30`	`30`	`\| ^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`	`32`	note: argument has type `&&SomeStruct`
`33`		`- --> $DIR/drop_ref.rs:13:10`
	`33`	`+ --> $DIR/drop_ref.rs:14:10`
`34`	`34`	`\|`
`35`	`35`	`LL \| drop(&&owned1);`
`36`	`36`	`\| ^^^^^^^^`
`37`	`37`
`38`	`38`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`39`		`- --> $DIR/drop_ref.rs:14:5`
	`39`	`+ --> $DIR/drop_ref.rs:15:5`
`40`	`40`	`\|`
`41`	`41`	`LL \| drop(&mut owned1);`
`42`	`42`	`\| ^^^^^^^^^^^^^^^^^`
`43`	`43`	`\|`
`44`	`44`	note: argument has type `&mut SomeStruct`
`45`		`- --> $DIR/drop_ref.rs:14:10`
	`45`	`+ --> $DIR/drop_ref.rs:15:10`
`46`	`46`	`\|`
`47`	`47`	`LL \| drop(&mut owned1);`
`48`	`48`	`\| ^^^^^^^^^^^`
`49`	`49`
`50`	`50`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`51`		`- --> $DIR/drop_ref.rs:18:5`
	`51`	`+ --> $DIR/drop_ref.rs:19:5`
`52`	`52`	`\|`
`53`	`53`	`LL \| drop(reference1);`
`54`	`54`	`\| ^^^^^^^^^^^^^^^^`
`55`	`55`	`\|`
`56`	`56`	note: argument has type `&SomeStruct`
`57`		`- --> $DIR/drop_ref.rs:18:10`
	`57`	`+ --> $DIR/drop_ref.rs:19:10`
`58`	`58`	`\|`
`59`	`59`	`LL \| drop(reference1);`
`60`	`60`	`\| ^^^^^^^^^^`
`61`	`61`
`62`	`62`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`63`		`- --> $DIR/drop_ref.rs:21:5`
	`63`	`+ --> $DIR/drop_ref.rs:22:5`
`64`	`64`	`\|`
`65`	`65`	`LL \| drop(reference2);`
`66`	`66`	`\| ^^^^^^^^^^^^^^^^`
`67`	`67`	`\|`
`68`	`68`	note: argument has type `&mut SomeStruct`
`69`		`- --> $DIR/drop_ref.rs:21:10`
	`69`	`+ --> $DIR/drop_ref.rs:22:10`
`70`	`70`	`\|`
`71`	`71`	`LL \| drop(reference2);`
`72`	`72`	`\| ^^^^^^^^^^`
`73`	`73`
`74`	`74`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`75`		`- --> $DIR/drop_ref.rs:24:5`
	`75`	`+ --> $DIR/drop_ref.rs:25:5`
`76`	`76`	`\|`
`77`	`77`	`LL \| drop(reference3);`
`78`	`78`	`\| ^^^^^^^^^^^^^^^^`
`79`	`79`	`\|`
`80`	`80`	note: argument has type `&SomeStruct`
`81`		`- --> $DIR/drop_ref.rs:24:10`
	`81`	`+ --> $DIR/drop_ref.rs:25:10`
`82`	`82`	`\|`
`83`	`83`	`LL \| drop(reference3);`
`84`	`84`	`\| ^^^^^^^^^^`
`85`	`85`
`86`	`86`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`87`		`- --> $DIR/drop_ref.rs:29:5`
	`87`	`+ --> $DIR/drop_ref.rs:30:5`
`88`	`88`	`\|`
`89`	`89`	`LL \| drop(&val);`
`90`	`90`	`\| ^^^^^^^^^^`
`91`	`91`	`\|`
`92`	`92`	note: argument has type `&T`
`93`		`- --> $DIR/drop_ref.rs:29:10`
	`93`	`+ --> $DIR/drop_ref.rs:30:10`
`94`	`94`	`\|`
`95`	`95`	`LL \| drop(&val);`
`96`	`96`	`\| ^^^^`
`97`	`97`
`98`	`98`	error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
`99`		`- --> $DIR/drop_ref.rs:37:5`
	`99`	`+ --> $DIR/drop_ref.rs:38:5`
`100`	`100`	`\|`
`101`	`101`	`LL \| std::mem::drop(&SomeStruct);`
`102`	`102`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`103`	`103`	`\|`
`104`	`104`	note: argument has type `&SomeStruct`
`105`		`- --> $DIR/drop_ref.rs:37:20`
	`105`	`+ --> $DIR/drop_ref.rs:38:20`
`106`	`106`	`\|`
`107`	`107`	`LL \| std::mem::drop(&SomeStruct);`
`108`	`108`	`\| ^^^^^^^^^^^`