Apply review comments

JohnTitor · JohnTitor · commit 4b133f2867b0 · 2020-01-26T07:01:16.000+09:00
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -2138,7 +2138,7 @@ fn lint_iter_nth<'a, 'tcx>(
         ITER_NTH,
         expr.span,
         &format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
-        &format!("Calling `.get{}()` is both faster and more readable", mut_str),
+        &format!("calling `.get{}()` is both faster and more readable", mut_str),
     );
 }
 
@@ -2247,7 +2247,7 @@ fn lint_iter_skip_next(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
             ITER_SKIP_NEXT,
             expr.span,
             "called `skip(x).next()` on an iterator",
-            "This is more succinctly expressed by calling `nth(x)`.",
+            "this is more succinctly expressed by calling `nth(x)`",
         );
     }
 }
@@ -2309,8 +2309,8 @@ fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, unwrap_args: &[hi
             expr.span,
             &format!("used `unwrap()` on `{}` value", kind,),
             &format!(
-                "If you don't want to handle the `{}` case gracefully, consider \
-                using `expect()` to provide a better panic message.",
+                "if you don't want to handle the `{}` case gracefully, consider \
+                using `expect()` to provide a better panic message",
                 none_value,
             ),
         );
@@ -2335,7 +2335,7 @@ fn lint_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, expect_args: &[hi
             lint,
             expr.span,
             &format!("used `expect()` on `{}` value", kind,),
-            &format!("If this value is an `{}`, it will panic.", none_value,),
+            &format!("if this value is an `{}`, it will panic", none_value,),
         );
     }
 }
@@ -2355,7 +2355,7 @@ fn lint_ok_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, ok_args: &[hir
                 OK_EXPECT,
                 expr.span,
                 "called `ok().expect()` on a `Result` value",
-                "You can call `expect()` directly on the `Result`",
+                "you can call `expect()` directly on the `Result`",
             );
         }
     }
@@ -2608,7 +2608,7 @@ fn lint_filter_map<'a, 'tcx>(
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter(p).map(q)` on an `Iterator`";
-        let hint = "This is more succinctly expressed by calling `.filter_map(..)` instead.";
+        let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
         span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);
     }
 }
@@ -2648,7 +2648,7 @@ fn lint_find_map<'a, 'tcx>(
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
         let msg = "called `find(p).map(q)` on an `Iterator`";
-        let hint = "This is more succinctly expressed by calling `.find_map(..)` instead.";
+        let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
         span_help_and_lint(cx, FIND_MAP, expr.span, msg, hint);
     }
 }
@@ -2663,7 +2663,7 @@ fn lint_filter_map_map<'a, 'tcx>(
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter_map(p).map(q)` on an `Iterator`";
-        let hint = "This is more succinctly expressed by only calling `.filter_map(..)` instead.";
+        let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
         span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);
     }
 }
@@ -2678,8 +2678,8 @@ fn lint_filter_flat_map<'a, 'tcx>(
     // lint if caller of `.filter().flat_map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter(p).flat_map(q)` on an `Iterator`";
-        let hint = "This is more succinctly expressed by calling `.flat_map(..)` \
-            and filtering by returning an empty Iterator.";
+        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
+            and filtering by returning `iter::empty()`";
         span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);
     }
 }
@@ -2694,8 +2694,8 @@ fn lint_filter_map_flat_map<'a, 'tcx>(
     // lint if caller of `.filter_map().flat_map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`";
-        let hint = "This is more succinctly expressed by calling `.flat_map(..)` \
-            and filtering by returning an empty Iterator.";
+        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
+            and filtering by returning `iter::empty()`";
         span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);
     }
 }
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
@@ -5,7 +5,7 @@ LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::option-expect-used` implied by `-D warnings`
-   = help: If this value is an `None`, it will panic.
+   = help: if this value is an `None`, it will panic
 
 error: used `expect()` on `a Result` value
   --> $DIR/expect.rs:10:13
@@ -14,7 +14,7 @@ LL |     let _ = res.expect("");
    |             ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-expect-used` implied by `-D warnings`
-   = help: If this value is an `Err`, it will panic.
+   = help: if this value is an `Err`, it will panic
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/filter_methods.stderr b/tests/ui/filter_methods.stderr
@@ -5,7 +5,7 @@ LL |     let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x *
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::filter-map` implied by `-D warnings`
-   = help: This is more succinctly expressed by calling `.filter_map(..)` instead.
+   = help: this is more succinctly expressed by calling `.filter_map(..)` instead
 
 error: called `filter(p).flat_map(q)` on an `Iterator`
   --> $DIR/filter_methods.rs:7:21
@@ -17,7 +17,7 @@ LL | |         .filter(|&x| x == 0)
 LL | |         .flat_map(|x| x.checked_mul(2))
    | |_______________________________________^
    |
-   = help: This is more succinctly expressed by calling `.flat_map(..)` and filtering by returning an empty Iterator.
+   = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
 error: called `filter_map(p).flat_map(q)` on an `Iterator`
   --> $DIR/filter_methods.rs:13:21
@@ -29,7 +29,7 @@ LL | |         .filter_map(|x| x.checked_mul(2))
 LL | |         .flat_map(|x| x.checked_mul(2))
    | |_______________________________________^
    |
-   = help: This is more succinctly expressed by calling `.flat_map(..)` and filtering by returning an empty Iterator.
+   = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
 error: called `filter_map(p).map(q)` on an `Iterator`
   --> $DIR/filter_methods.rs:19:21
@@ -41,7 +41,7 @@ LL | |         .filter_map(|x| x.checked_mul(2))
 LL | |         .map(|x| x.checked_mul(2))
    | |__________________________________^
    |
-   = help: This is more succinctly expressed by only calling `.filter_map(..)` instead.
+   = help: this is more succinctly expressed by only calling `.filter_map(..)` instead
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/find_map.stderr b/tests/ui/find_map.stderr
@@ -5,7 +5,7 @@ LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::find-map` implied by `-D warnings`
-   = help: This is more succinctly expressed by calling `.find_map(..)` instead.
+   = help: this is more succinctly expressed by calling `.find_map(..)` instead
 
 error: called `find(p).map(q)` on an `Iterator`
   --> $DIR/find_map.rs:22:29
@@ -20,7 +20,7 @@ LL | |             _ => unreachable!(),
 LL | |         });
    | |__________^
    |
-   = help: This is more succinctly expressed by calling `.find_map(..)` instead.
+   = help: this is more succinctly expressed by calling `.find_map(..)` instead
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/iter_nth.stderr b/tests/ui/iter_nth.stderr
@@ -5,55 +5,55 @@ LL |         let bad_vec = some_vec.iter().nth(3);
    |                       ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::iter-nth` implied by `-D warnings`
-   = help: Calling `.get()` is both faster and more readable
+   = help: calling `.get()` is both faster and more readable
 
 error: called `.iter().nth()` on a slice
   --> $DIR/iter_nth.rs:34:26
    |
 LL |         let bad_slice = &some_vec[..].iter().nth(3);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get()` is both faster and more readable
+   = help: calling `.get()` is both faster and more readable
 
 error: called `.iter().nth()` on a slice
   --> $DIR/iter_nth.rs:35:31
    |
 LL |         let bad_boxed_slice = boxed_slice.iter().nth(3);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get()` is both faster and more readable
+   = help: calling `.get()` is both faster and more readable
 
 error: called `.iter().nth()` on a VecDeque
   --> $DIR/iter_nth.rs:36:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter().nth(3);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get()` is both faster and more readable
+   = help: calling `.get()` is both faster and more readable
 
 error: called `.iter_mut().nth()` on a Vec
   --> $DIR/iter_nth.rs:41:23
    |
 LL |         let bad_vec = some_vec.iter_mut().nth(3);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get_mut()` is both faster and more readable
+   = help: calling `.get_mut()` is both faster and more readable
 
 error: called `.iter_mut().nth()` on a slice
   --> $DIR/iter_nth.rs:44:26
    |
 LL |         let bad_slice = &some_vec[..].iter_mut().nth(3);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get_mut()` is both faster and more readable
+   = help: calling `.get_mut()` is both faster and more readable
 
 error: called `.iter_mut().nth()` on a VecDeque
   --> $DIR/iter_nth.rs:47:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Calling `.get_mut()` is both faster and more readable
+   = help: calling `.get_mut()` is both faster and more readable
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/iter_skip_next.stderr b/tests/ui/iter_skip_next.stderr
@@ -5,31 +5,31 @@ LL |     let _ = some_vec.iter().skip(42).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::iter-skip-next` implied by `-D warnings`
-   = help: This is more succinctly expressed by calling `nth(x)`.
+   = help: this is more succinctly expressed by calling `nth(x)`
 
 error: called `skip(x).next()` on an iterator
   --> $DIR/iter_skip_next.rs:14:13
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: This is more succinctly expressed by calling `nth(x)`.
+   = help: this is more succinctly expressed by calling `nth(x)`
 
 error: called `skip(x).next()` on an iterator
   --> $DIR/iter_skip_next.rs:15:13
    |
 LL |     let _ = (1..10).skip(10).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: This is more succinctly expressed by calling `nth(x)`.
+   = help: this is more succinctly expressed by calling `nth(x)`
 
 error: called `skip(x).next()` on an iterator
   --> $DIR/iter_skip_next.rs:16:14
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: This is more succinctly expressed by calling `nth(x)`.
+   = help: this is more succinctly expressed by calling `nth(x)`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/ok_expect.stderr b/tests/ui/ok_expect.stderr
@@ -5,39 +5,39 @@ LL |     res.ok().expect("disaster!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::ok-expect` implied by `-D warnings`
-   = help: You can call `expect()` directly on the `Result`
+   = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
   --> $DIR/ok_expect.rs:20:5
    |
 LL |     res3.ok().expect("whoof");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: You can call `expect()` directly on the `Result`
+   = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
   --> $DIR/ok_expect.rs:22:5
    |
 LL |     res4.ok().expect("argh");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: You can call `expect()` directly on the `Result`
+   = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
   --> $DIR/ok_expect.rs:24:5
    |
 LL |     res5.ok().expect("oops");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: You can call `expect()` directly on the `Result`
+   = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
   --> $DIR/ok_expect.rs:26:5
    |
 LL |     res6.ok().expect("meh");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: You can call `expect()` directly on the `Result`
+   = help: you can call `expect()` directly on the `Result`
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/unwrap.stderr b/tests/ui/unwrap.stderr
@@ -5,7 +5,7 @@ LL |     let _ = opt.unwrap();
    |             ^^^^^^^^^^^^
    |
    = note: `-D clippy::option-unwrap-used` implied by `-D warnings`
-   = help: If you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message.
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: used `unwrap()` on `a Result` value
   --> $DIR/unwrap.rs:10:13
@@ -14,7 +14,7 @@ LL |     let _ = res.unwrap();
    |             ^^^^^^^^^^^^
    |
    = note: `-D clippy::result-unwrap-used` implied by `-D warnings`
-   = help: If you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message.
+   = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
 
 error: aborting due to 2 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -2138,7 +2138,7 @@ fn lint_iter_nth<'a, 'tcx>(`
`2138`	`2138`	`ITER_NTH,`
`2139`	`2139`	`expr.span,`
`2140`	`2140`	&format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
`2141`		- &format!("Calling `.get{}()` is both faster and more readable", mut_str),
	`2141`	+ &format!("calling `.get{}()` is both faster and more readable", mut_str),
`2142`	`2142`	`);`
`2143`	`2143`	`}`
`2144`	`2144`
`@@ -2247,7 +2247,7 @@ fn lint_iter_skip_next(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {`
`2247`	`2247`	`ITER_SKIP_NEXT,`
`2248`	`2248`	`expr.span,`
`2249`	`2249`	"called `skip(x).next()` on an iterator",
`2250`		- "This is more succinctly expressed by calling `nth(x)`.",
	`2250`	+ "this is more succinctly expressed by calling `nth(x)`",
`2251`	`2251`	`);`
`2252`	`2252`	`}`
`2253`	`2253`	`}`
`@@ -2309,8 +2309,8 @@ fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, unwrap_args: &[hi`
`2309`	`2309`	`expr.span,`
`2310`	`2310`	&format!("used `unwrap()` on `{}` value", kind,),
`2311`	`2311`	`&format!(`
`2312`		- "If you don't want to handle the `{}` case gracefully, consider \
`2313`		- using `expect()` to provide a better panic message.",
	`2312`	+ "if you don't want to handle the `{}` case gracefully, consider \
	`2313`	+ using `expect()` to provide a better panic message",
`2314`	`2314`	`none_value,`
`2315`	`2315`	`),`
`2316`	`2316`	`);`
`@@ -2335,7 +2335,7 @@ fn lint_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, expect_args: &[hi`
`2335`	`2335`	`lint,`
`2336`	`2336`	`expr.span,`
`2337`	`2337`	&format!("used `expect()` on `{}` value", kind,),
`2338`		- &format!("If this value is an `{}`, it will panic.", none_value,),
	`2338`	+ &format!("if this value is an `{}`, it will panic", none_value,),
`2339`	`2339`	`);`
`2340`	`2340`	`}`
`2341`	`2341`	`}`
`@@ -2355,7 +2355,7 @@ fn lint_ok_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, ok_args: &[hir`
`2355`	`2355`	`OK_EXPECT,`
`2356`	`2356`	`expr.span,`
`2357`	`2357`	"called `ok().expect()` on a `Result` value",
`2358`		- "You can call `expect()` directly on the `Result`",
	`2358`	+ "you can call `expect()` directly on the `Result`",
`2359`	`2359`	`);`
`2360`	`2360`	`}`
`2361`	`2361`	`}`
`@@ -2608,7 +2608,7 @@ fn lint_filter_map<'a, 'tcx>(`
`2608`	`2608`	// lint if caller of `.filter().map()` is an Iterator
`2609`	`2609`	`if match_trait_method(cx, expr, &paths::ITERATOR) {`
`2610`	`2610`	let msg = "called `filter(p).map(q)` on an `Iterator`";
`2611`		- let hint = "This is more succinctly expressed by calling `.filter_map(..)` instead.";
	`2611`	+ let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
`2612`	`2612`	`span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);`
`2613`	`2613`	`}`
`2614`	`2614`	`}`
`@@ -2648,7 +2648,7 @@ fn lint_find_map<'a, 'tcx>(`
`2648`	`2648`	// lint if caller of `.filter().map()` is an Iterator
`2649`	`2649`	`if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {`
`2650`	`2650`	let msg = "called `find(p).map(q)` on an `Iterator`";
`2651`		- let hint = "This is more succinctly expressed by calling `.find_map(..)` instead.";
	`2651`	+ let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
`2652`	`2652`	`span_help_and_lint(cx, FIND_MAP, expr.span, msg, hint);`
`2653`	`2653`	`}`
`2654`	`2654`	`}`
`@@ -2663,7 +2663,7 @@ fn lint_filter_map_map<'a, 'tcx>(`
`2663`	`2663`	// lint if caller of `.filter().map()` is an Iterator
`2664`	`2664`	`if match_trait_method(cx, expr, &paths::ITERATOR) {`
`2665`	`2665`	let msg = "called `filter_map(p).map(q)` on an `Iterator`";
`2666`		- let hint = "This is more succinctly expressed by only calling `.filter_map(..)` instead.";
	`2666`	+ let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
`2667`	`2667`	`span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);`
`2668`	`2668`	`}`
`2669`	`2669`	`}`
`@@ -2678,8 +2678,8 @@ fn lint_filter_flat_map<'a, 'tcx>(`
`2678`	`2678`	// lint if caller of `.filter().flat_map()` is an Iterator
`2679`	`2679`	`if match_trait_method(cx, expr, &paths::ITERATOR) {`
`2680`	`2680`	let msg = "called `filter(p).flat_map(q)` on an `Iterator`";
`2681`		- let hint = "This is more succinctly expressed by calling `.flat_map(..)` \
`2682`		`- and filtering by returning an empty Iterator.";`
	`2681`	+ let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
	`2682`	+ and filtering by returning `iter::empty()`";
`2683`	`2683`	`span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);`
`2684`	`2684`	`}`
`2685`	`2685`	`}`
`@@ -2694,8 +2694,8 @@ fn lint_filter_map_flat_map<'a, 'tcx>(`
`2694`	`2694`	// lint if caller of `.filter_map().flat_map()` is an Iterator
`2695`	`2695`	`if match_trait_method(cx, expr, &paths::ITERATOR) {`
`2696`	`2696`	let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`";
`2697`		- let hint = "This is more succinctly expressed by calling `.flat_map(..)` \
`2698`		`- and filtering by returning an empty Iterator.";`
	`2697`	+ let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
	`2698`	+ and filtering by returning `iter::empty()`";
`2699`	`2699`	`span_help_and_lint(cx, FILTER_MAP, expr.span, msg, hint);`
`2700`	`2700`	`}`
`2701`	`2701`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ LL \| let _ = opt.expect("");`
`5`	`5`	`\| ^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::option-expect-used` implied by `-D warnings`
`8`		- = help: If this value is an `None`, it will panic.
	`8`	+ = help: if this value is an `None`, it will panic
`9`	`9`
`10`	`10`	error: used `expect()` on `a Result` value
`11`	`11`	`--> $DIR/expect.rs:10:13`
`@@ -14,7 +14,7 @@ LL \| let _ = res.expect("");`
`14`	`14`	`\| ^^^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`	`16`	= note: `-D clippy::result-expect-used` implied by `-D warnings`
`17`		- = help: If this value is an `Err`, it will panic.
	`17`	+ = help: if this value is an `Err`, it will panic
`18`	`18`
`19`	`19`	`error: aborting due to 2 previous errors`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ LL \| let _: Option<i32> = a.iter().find(\|s\| s.parse::<i32>().is_ok()).map(\|s`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::find-map` implied by `-D warnings`
`8`		- = help: This is more succinctly expressed by calling `.find_map(..)` instead.
	`8`	+ = help: this is more succinctly expressed by calling `.find_map(..)` instead
`9`	`9`
`10`	`10`	error: called `find(p).map(q)` on an `Iterator`
`11`	`11`	`--> $DIR/find_map.rs:22:29`
`@@ -20,7 +20,7 @@ LL \| \| _ => unreachable!(),`
`20`	`20`	`LL \| \| });`
`21`	`21`	`\| \|__________^`
`22`	`22`	`\|`
`23`		- = help: This is more succinctly expressed by calling `.find_map(..)` instead.
	`23`	+ = help: this is more succinctly expressed by calling `.find_map(..)` instead
`24`	`24`
`25`	`25`	`error: aborting due to 2 previous errors`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -5,55 +5,55 @@ LL \| let bad_vec = some_vec.iter().nth(3);`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::iter-nth` implied by `-D warnings`
`8`		- = help: Calling `.get()` is both faster and more readable
	`8`	+ = help: calling `.get()` is both faster and more readable
`9`	`9`
`10`	`10`	error: called `.iter().nth()` on a slice
`11`	`11`	`--> $DIR/iter_nth.rs:34:26`
`12`	`12`	`\|`
`13`	`13`	`LL \| let bad_slice = &some_vec[..].iter().nth(3);`
`14`	`14`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`		- = help: Calling `.get()` is both faster and more readable
	`16`	+ = help: calling `.get()` is both faster and more readable
`17`	`17`
`18`	`18`	error: called `.iter().nth()` on a slice
`19`	`19`	`--> $DIR/iter_nth.rs:35:31`
`20`	`20`	`\|`
`21`	`21`	`LL \| let bad_boxed_slice = boxed_slice.iter().nth(3);`
`22`	`22`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^`
`23`	`23`	`\|`
`24`		- = help: Calling `.get()` is both faster and more readable
	`24`	+ = help: calling `.get()` is both faster and more readable
`25`	`25`
`26`	`26`	error: called `.iter().nth()` on a VecDeque
`27`	`27`	`--> $DIR/iter_nth.rs:36:29`
`28`	`28`	`\|`
`29`	`29`	`LL \| let bad_vec_deque = some_vec_deque.iter().nth(3);`
`30`	`30`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`		- = help: Calling `.get()` is both faster and more readable
	`32`	+ = help: calling `.get()` is both faster and more readable
`33`	`33`
`34`	`34`	error: called `.iter_mut().nth()` on a Vec
`35`	`35`	`--> $DIR/iter_nth.rs:41:23`
`36`	`36`	`\|`
`37`	`37`	`LL \| let bad_vec = some_vec.iter_mut().nth(3);`
`38`	`38`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`39`	`39`	`\|`
`40`		- = help: Calling `.get_mut()` is both faster and more readable
	`40`	+ = help: calling `.get_mut()` is both faster and more readable
`41`	`41`
`42`	`42`	error: called `.iter_mut().nth()` on a slice
`43`	`43`	`--> $DIR/iter_nth.rs:44:26`
`44`	`44`	`\|`
`45`	`45`	`LL \| let bad_slice = &some_vec[..].iter_mut().nth(3);`
`46`	`46`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`47`	`47`	`\|`
`48`		- = help: Calling `.get_mut()` is both faster and more readable
	`48`	+ = help: calling `.get_mut()` is both faster and more readable
`49`	`49`
`50`	`50`	error: called `.iter_mut().nth()` on a VecDeque
`51`	`51`	`--> $DIR/iter_nth.rs:47:29`
`52`	`52`	`\|`
`53`	`53`	`LL \| let bad_vec_deque = some_vec_deque.iter_mut().nth(3);`
`54`	`54`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`55`	`55`	`\|`
`56`		- = help: Calling `.get_mut()` is both faster and more readable
	`56`	+ = help: calling `.get_mut()` is both faster and more readable
`57`	`57`
`58`	`58`	`error: aborting due to 7 previous errors`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -5,31 +5,31 @@ LL \| let _ = some_vec.iter().skip(42).next();`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::iter-skip-next` implied by `-D warnings`
`8`		- = help: This is more succinctly expressed by calling `nth(x)`.
	`8`	+ = help: this is more succinctly expressed by calling `nth(x)`
`9`	`9`
`10`	`10`	error: called `skip(x).next()` on an iterator
`11`	`11`	`--> $DIR/iter_skip_next.rs:14:13`
`12`	`12`	`\|`
`13`	`13`	`LL \| let _ = some_vec.iter().cycle().skip(42).next();`
`14`	`14`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`		- = help: This is more succinctly expressed by calling `nth(x)`.
	`16`	+ = help: this is more succinctly expressed by calling `nth(x)`
`17`	`17`
`18`	`18`	error: called `skip(x).next()` on an iterator
`19`	`19`	`--> $DIR/iter_skip_next.rs:15:13`
`20`	`20`	`\|`
`21`	`21`	`LL \| let _ = (1..10).skip(10).next();`
`22`	`22`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`23`	`23`	`\|`
`24`		- = help: This is more succinctly expressed by calling `nth(x)`.
	`24`	+ = help: this is more succinctly expressed by calling `nth(x)`
`25`	`25`
`26`	`26`	error: called `skip(x).next()` on an iterator
`27`	`27`	`--> $DIR/iter_skip_next.rs:16:14`
`28`	`28`	`\|`
`29`	`29`	`LL \| let _ = &some_vec[..].iter().skip(3).next();`
`30`	`30`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`		- = help: This is more succinctly expressed by calling `nth(x)`.
	`32`	+ = help: this is more succinctly expressed by calling `nth(x)`
`33`	`33`
`34`	`34`	`error: aborting due to 4 previous errors`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -5,39 +5,39 @@ LL \| res.ok().expect("disaster!");`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::ok-expect` implied by `-D warnings`
`8`		- = help: You can call `expect()` directly on the `Result`
	`8`	+ = help: you can call `expect()` directly on the `Result`
`9`	`9`
`10`	`10`	error: called `ok().expect()` on a `Result` value
`11`	`11`	`--> $DIR/ok_expect.rs:20:5`
`12`	`12`	`\|`
`13`	`13`	`LL \| res3.ok().expect("whoof");`
`14`	`14`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`		- = help: You can call `expect()` directly on the `Result`
	`16`	+ = help: you can call `expect()` directly on the `Result`
`17`	`17`
`18`	`18`	error: called `ok().expect()` on a `Result` value
`19`	`19`	`--> $DIR/ok_expect.rs:22:5`
`20`	`20`	`\|`
`21`	`21`	`LL \| res4.ok().expect("argh");`
`22`	`22`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`23`	`23`	`\|`
`24`		- = help: You can call `expect()` directly on the `Result`
	`24`	+ = help: you can call `expect()` directly on the `Result`
`25`	`25`
`26`	`26`	error: called `ok().expect()` on a `Result` value
`27`	`27`	`--> $DIR/ok_expect.rs:24:5`
`28`	`28`	`\|`
`29`	`29`	`LL \| res5.ok().expect("oops");`
`30`	`30`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`31`	`31`	`\|`
`32`		- = help: You can call `expect()` directly on the `Result`
	`32`	+ = help: you can call `expect()` directly on the `Result`
`33`	`33`
`34`	`34`	error: called `ok().expect()` on a `Result` value
`35`	`35`	`--> $DIR/ok_expect.rs:26:5`
`36`	`36`	`\|`
`37`	`37`	`LL \| res6.ok().expect("meh");`
`38`	`38`	`\| ^^^^^^^^^^^^^^^^^^^^^^^`
`39`	`39`	`\|`
`40`		- = help: You can call `expect()` directly on the `Result`
	`40`	+ = help: you can call `expect()` directly on the `Result`
`41`	`41`
`42`	`42`	`error: aborting due to 5 previous errors`
`43`	`43`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ LL \| let _ = opt.unwrap();`
`5`	`5`	`\| ^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `-D clippy::option-unwrap-used` implied by `-D warnings`
`8`		- = help: If you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message.
	`8`	+ = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
`9`	`9`
`10`	`10`	error: used `unwrap()` on `a Result` value
`11`	`11`	`--> $DIR/unwrap.rs:10:13`
`@@ -14,7 +14,7 @@ LL \| let _ = res.unwrap();`
`14`	`14`	`\| ^^^^^^^^^^^^`
`15`	`15`	`\|`
`16`	`16`	= note: `-D clippy::result-unwrap-used` implied by `-D warnings`
`17`		- = help: If you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message.
	`17`	+ = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
`18`	`18`
`19`	`19`	`error: aborting due to 2 previous errors`
`20`	`20`