Update stderr files

hkmatsumoto · hkmatsumoto · commit 548b43be2df4 · 2020-11-14T18:26:50.000+09:00
diff --git a/tests/ui/doc_errors.stderr b/tests/ui/doc_errors.stderr
@@ -1,5 +1,5 @@
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:7:1
+  --> $DIR/doc_errors.rs:8:1
    |
 LL | / pub fn pub_fn_missing_errors_header() -> Result<(), ()> {
 LL | |     unimplemented!();
@@ -9,47 +9,47 @@ LL | | }
    = note: `-D clippy::missing-errors-doc` implied by `-D warnings`
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:11:1
+  --> $DIR/doc_errors.rs:12:1
    |
 LL | / pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
 LL | |     unimplemented!();
 LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:16:1
+  --> $DIR/doc_errors.rs:17:1
    |
 LL | / pub fn pub_fn_returning_io_result() -> io::Result<()> {
 LL | |     unimplemented!();
 LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:21:1
+  --> $DIR/doc_errors.rs:22:1
    |
 LL | / pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
 LL | |     unimplemented!();
 LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:51:5
+  --> $DIR/doc_errors.rs:52:5
    |
 LL | /     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:56:5
+  --> $DIR/doc_errors.rs:57:5
    |
 LL | /     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:85:5
+  --> $DIR/doc_errors.rs:86:5
    |
 LL |     fn trait_method_missing_errors_header() -> Result<(), ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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:10:5
+  --> $DIR/drop_ref.rs:11:5
    |
 LL |     drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::drop-ref` implied by `-D warnings`
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:10:10
+  --> $DIR/drop_ref.rs:11: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: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(&&owned1);
    |     ^^^^^^^^^^^^^^
    |
 note: argument has type `&&SomeStruct`
-  --> $DIR/drop_ref.rs:14:10
+  --> $DIR/drop_ref.rs:15: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:15:5
+  --> $DIR/drop_ref.rs:16:5
    |
 LL |     drop(&mut owned1);
    |     ^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:15:10
+  --> $DIR/drop_ref.rs:16: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:19:5
+  --> $DIR/drop_ref.rs:20:5
    |
 LL |     drop(reference1);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:19:10
+  --> $DIR/drop_ref.rs:20: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:22:5
+  --> $DIR/drop_ref.rs:23:5
    |
 LL |     drop(reference2);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:22:10
+  --> $DIR/drop_ref.rs:23: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:25:5
+  --> $DIR/drop_ref.rs:26:5
    |
 LL |     drop(reference3);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:25:10
+  --> $DIR/drop_ref.rs:26: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:30:5
+  --> $DIR/drop_ref.rs:31:5
    |
 LL |     drop(&val);
    |     ^^^^^^^^^^
    |
 note: argument has type `&T`
-  --> $DIR/drop_ref.rs:30:10
+  --> $DIR/drop_ref.rs:31: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:38:5
+  --> $DIR/drop_ref.rs:39:5
    |
 LL |     std::mem::drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:38:20
+  --> $DIR/drop_ref.rs:39:20
    |
 LL |     std::mem::drop(&SomeStruct);
    |                    ^^^^^^^^^^^
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(dead_code)]
-#![allow(unused_variables)]
+#![allow(unused_variables, clippy::unnecessary_wrap)]
 
 fn option_unwrap_or() {
     // int case
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(dead_code)]
-#![allow(unused_variables)]
+#![allow(unused_variables, clippy::unnecessary_wrap)]
 
 fn option_unwrap_or() {
     // int case
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::map_err_ignore)]
+#![allow(clippy::unnecessary_wrap)]
 use std::convert::TryFrom;
 use std::error::Error;
 use std::fmt;
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
@@ -1,5 +1,5 @@
 error: `map_err(|_|...` ignores the original error
-  --> $DIR/map_err.rs:22:32
+  --> $DIR/map_err.rs:23:32
    |
 LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    |                                ^^^
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
@@ -61,19 +61,19 @@ LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:62:19
+  --> $DIR/or_fun_call.rs:63:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:65:21
+  --> $DIR/or_fun_call.rs:66:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:68:21
+  --> $DIR/or_fun_call.rs:69:21
    |
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
diff --git a/tests/ui/redundant_pattern_matching.stderr b/tests/ui/redundant_pattern_matching.stderr
@@ -19,19 +19,19 @@ LL |     if let Err(_) = Err::<i32, i32>(42) {}
    |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:21:15
+  --> $DIR/redundant_pattern_matching.rs:22:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:23:15
+  --> $DIR/redundant_pattern_matching.rs:24:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:33:5
+  --> $DIR/redundant_pattern_matching.rs:34:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -40,7 +40,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:38:5
+  --> $DIR/redundant_pattern_matching.rs:39:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -49,7 +49,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:43:5
+  --> $DIR/redundant_pattern_matching.rs:44:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -58,7 +58,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:48:5
+  --> $DIR/redundant_pattern_matching.rs:49:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -67,73 +67,73 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:53:20
+  --> $DIR/redundant_pattern_matching.rs:54:20
    |
 LL |     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
    |             -------^^^^^--------------------- help: try this: `if Ok::<usize, ()>(4).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:59:20
+  --> $DIR/redundant_pattern_matching.rs:60:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:61:19
+  --> $DIR/redundant_pattern_matching.rs:62:19
    |
 LL |     } else if let Err(_) = gen_res() {
    |            -------^^^^^^------------ help: try this: `if gen_res().is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:84:19
+  --> $DIR/redundant_pattern_matching.rs:85:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
    |         ----------^^^^^^^----------------------- help: try this: `while r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:85:16
+  --> $DIR/redundant_pattern_matching.rs:86:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
    |         -------^^^^^^^----------------------- help: try this: `if r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:91:12
+  --> $DIR/redundant_pattern_matching.rs:92:12
    |
 LL |     if let Some(_) = m!() {}
    |     -------^^^^^^^------- help: try this: `if m!().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:92:15
+  --> $DIR/redundant_pattern_matching.rs:93:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:110:12
+  --> $DIR/redundant_pattern_matching.rs:111:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:112:12
+  --> $DIR/redundant_pattern_matching.rs:113:12
    |
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
    |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:114:15
+  --> $DIR/redundant_pattern_matching.rs:115:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:116:15
+  --> $DIR/redundant_pattern_matching.rs:117:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:118:5
+  --> $DIR/redundant_pattern_matching.rs:119:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:123:5
+  --> $DIR/redundant_pattern_matching.rs:124:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
diff --git a/tests/ui/result_unit_error.rs b/tests/ui/result_unit_error.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::unnecessary_wrap)]
 #[warn(clippy::result_unit_err)]
 #[allow(unused)]
 
diff --git a/tests/ui/result_unit_error.stderr b/tests/ui/result_unit_error.stderr

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:10:5`
	`2`	`+ --> $DIR/drop_ref.rs:11: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:10:10`
	`9`	`+ --> $DIR/drop_ref.rs:11: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:13:5`
	`15`	`+ --> $DIR/drop_ref.rs:14:5`
`16`	`16`	`\|`
`17`	`17`	`LL \| drop(&owned1);`
`18`	`18`	`\| ^^^^^^^^^^^^^`
`19`	`19`	`\|`
`20`	`20`	note: argument has type `&SomeStruct`
`21`		`- --> $DIR/drop_ref.rs:13:10`
	`21`	`+ --> $DIR/drop_ref.rs:14: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:14:5`
	`27`	`+ --> $DIR/drop_ref.rs:15:5`
`28`	`28`	`\|`
`29`	`29`	`LL \| drop(&&owned1);`
`30`	`30`	`\| ^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`	`32`	note: argument has type `&&SomeStruct`
`33`		`- --> $DIR/drop_ref.rs:14:10`
	`33`	`+ --> $DIR/drop_ref.rs:15: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:15:5`
	`39`	`+ --> $DIR/drop_ref.rs:16: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:15:10`
	`45`	`+ --> $DIR/drop_ref.rs:16: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:19:5`
	`51`	`+ --> $DIR/drop_ref.rs:20:5`
`52`	`52`	`\|`
`53`	`53`	`LL \| drop(reference1);`
`54`	`54`	`\| ^^^^^^^^^^^^^^^^`
`55`	`55`	`\|`
`56`	`56`	note: argument has type `&SomeStruct`
`57`		`- --> $DIR/drop_ref.rs:19:10`
	`57`	`+ --> $DIR/drop_ref.rs:20: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:22:5`
	`63`	`+ --> $DIR/drop_ref.rs:23: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:22:10`
	`69`	`+ --> $DIR/drop_ref.rs:23: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:25:5`
	`75`	`+ --> $DIR/drop_ref.rs:26:5`
`76`	`76`	`\|`
`77`	`77`	`LL \| drop(reference3);`
`78`	`78`	`\| ^^^^^^^^^^^^^^^^`
`79`	`79`	`\|`
`80`	`80`	note: argument has type `&SomeStruct`
`81`		`- --> $DIR/drop_ref.rs:25:10`
	`81`	`+ --> $DIR/drop_ref.rs:26: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:30:5`
	`87`	`+ --> $DIR/drop_ref.rs:31:5`
`88`	`88`	`\|`
`89`	`89`	`LL \| drop(&val);`
`90`	`90`	`\| ^^^^^^^^^^`
`91`	`91`	`\|`
`92`	`92`	note: argument has type `&T`
`93`		`- --> $DIR/drop_ref.rs:30:10`
	`93`	`+ --> $DIR/drop_ref.rs:31: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:38:5`
	`99`	`+ --> $DIR/drop_ref.rs:39: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:38:20`
	`105`	`+ --> $DIR/drop_ref.rs:39:20`
`106`	`106`	`\|`
`107`	`107`	`LL \| std::mem::drop(&SomeStruct);`
`108`	`108`	`\| ^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#![warn(clippy::map_err_ignore)]`
	`2`	`+#![allow(clippy::unnecessary_wrap)]`
`2`	`3`	`use std::convert::TryFrom;`
`3`	`4`	`use std::error::Error;`
`4`	`5`	`use std::fmt;`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error: `map_err(\|_\|...` ignores the original error
`2`		`- --> $DIR/map_err.rs:22:32`
	`2`	`+ --> $DIR/map_err.rs:23:32`
`3`	`3`	`\|`
`4`	`4`	`LL \| println!("{:?}", x.map_err(\|_\| Errors::Ignored));`
`5`	`5`	`\| ^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+#![allow(clippy::unnecessary_wrap)]`
`1`	`2`	`#[warn(clippy::result_unit_err)]`
`2`	`3`	`#[allow(unused)]`
`3`	`4`