From 60c7bd47a56f72938bdd8a7dce328f414e1bc78f Mon Sep 17 00:00:00 2001 From: cgm616 Date: Sat, 21 Oct 2017 07:53:57 -0400 Subject: [PATCH] Prevent should_implement_trait on private method This should close #2159. --- clippy_lints/src/methods.rs | 143 ++++++++++----- tests/ui/methods.rs | 7 +- tests/ui/methods.stderr | 354 ++++++++++++++++++------------------ 3 files changed, 278 insertions(+), 226 deletions(-) diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index 849f0024415..54523841b09 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -335,7 +335,8 @@ declare_lint! { /// the corresponding trait instead. /// /// **Why is this bad?**: Calling '.clone()' on an Rc, Arc, or Weak -/// can obscure the fact that only the pointer is being cloned, not the underlying +/// can obscure the fact that only the pointer is being cloned, not the +/// underlying /// data. /// /// **Example:** @@ -714,15 +715,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir.body(id)).next(), let hir::ItemImpl(_, _, _, _, None, ref self_ty, _) = item.node, ], { - // check missing trait implementations - for &(method_name, n_args, self_kind, out_type, trait_name) in &TRAIT_METHODS { - if name == method_name && - sig.decl.inputs.len() == n_args && - out_type.matches(&sig.decl.output) && - self_kind.matches(first_arg_ty, first_arg, self_ty, false, &sig.generics) { - span_lint(cx, SHOULD_IMPLEMENT_TRAIT, implitem.span, &format!( - "defining a method called `{}` on this type; consider implementing \ - the `{}` trait or choosing a less ambiguous name", name, trait_name)); + if implitem.vis == hir::Visibility::Public || + implitem.vis.is_pub_restricted() { + // check missing trait implementations + for &(method_name, n_args, self_kind, out_type, trait_name) in &TRAIT_METHODS { + if name == method_name && + sig.decl.inputs.len() == n_args && + out_type.matches(&sig.decl.output) && + self_kind.matches(first_arg_ty, first_arg, self_ty, false, &sig.generics) { + span_lint(cx, SHOULD_IMPLEMENT_TRAIT, implitem.span, &format!( + "defining a method called `{}` on this type; consider implementing \ + the `{}` trait or choosing a less ambiguous name", name, trait_name)); + } } } @@ -941,12 +945,8 @@ fn lint_clone_on_ref_ptr(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr) { expr.span, "using '.clone()' on a ref-counted pointer", "try this", - format!("{}::clone(&{})", - caller_type, - snippet(cx, arg.span, "_") - ) + format!("{}::clone(&{})", caller_type, snippet(cx, arg.span, "_")), ); - } @@ -1004,8 +1004,8 @@ fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwr } fn lint_iter_cloned_collect(cx: &LateContext, expr: &hir::Expr, iter_args: &[hir::Expr]) { - if match_type(cx, cx.tables.expr_ty(expr), &paths::VEC) && - derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0])).is_some() + if match_type(cx, cx.tables.expr_ty(expr), &paths::VEC) + && derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0])).is_some() { span_lint( cx, @@ -1180,8 +1180,16 @@ fn lint_map_unwrap_or(cx: &LateContext, expr: &hir::Expr, map_args: &[hir::Expr] // lint message // comparing the snippet from source to raw text ("None") below is safe // because we already have checked the type. - let arg = if unwrap_snippet == "None" { "None" } else { "a" }; - let suggest = if unwrap_snippet == "None" { "and_then(f)" } else { "map_or(a, f)" }; + let arg = if unwrap_snippet == "None" { + "None" + } else { + "a" + }; + let suggest = if unwrap_snippet == "None" { + "and_then(f)" + } else { + "map_or(a, f)" + }; let msg = &format!( "called `map(f).unwrap_or({})` on an Option value. \ This can be done more directly by calling `{}` instead", @@ -1212,7 +1220,12 @@ fn lint_map_unwrap_or(cx: &LateContext, expr: &hir::Expr, map_args: &[hir::Expr] } /// lint use of `map().unwrap_or_else()` for `Option`s -fn lint_map_unwrap_or_else<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, map_args: &'tcx [hir::Expr], unwrap_args: &'tcx [hir::Expr]) { +fn lint_map_unwrap_or_else<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + expr: &'tcx hir::Expr, + map_args: &'tcx [hir::Expr], + unwrap_args: &'tcx [hir::Expr], +) { // lint if the caller of `map()` is an `Option` if match_type(cx, cx.tables.expr_ty(&map_args[0]), &paths::OPTION) { // lint message @@ -1246,7 +1259,6 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir /// lint use of `_.map_or(None, _)` for `Option`s fn lint_map_or_none<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, map_or_args: &'tcx [hir::Expr]) { - if match_type(cx, cx.tables.expr_ty(&map_or_args[0]), &paths::OPTION) { // check if the first non-self argument to map_or() is None let map_or_arg_is_none = if let hir::Expr_::ExprPath(ref qpath) = map_or_args[1].node { @@ -1262,13 +1274,9 @@ fn lint_map_or_none<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, let map_or_self_snippet = snippet(cx, map_or_args[0].span, ".."); let map_or_func_snippet = snippet(cx, map_or_args[2].span, ".."); let hint = format!("{0}.and_then({1})", map_or_self_snippet, map_or_func_snippet); - span_lint_and_then( - cx, - OPTION_MAP_OR_NONE, - expr.span, - msg, - |db| { db.span_suggestion(expr.span, "try using and_then instead", hint); }, - ); + span_lint_and_then(cx, OPTION_MAP_OR_NONE, expr.span, msg, |db| { + db.span_suggestion(expr.span, "try using and_then instead", hint); + }); } } } @@ -1297,7 +1305,12 @@ fn lint_filter_next<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, } /// lint use of `filter().map()` for `Iterators` -fn lint_filter_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, _filter_args: &'tcx [hir::Expr], _map_args: &'tcx [hir::Expr]) { +fn lint_filter_map<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + expr: &'tcx hir::Expr, + _filter_args: &'tcx [hir::Expr], + _map_args: &'tcx [hir::Expr], +) { // 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`. \ @@ -1307,7 +1320,12 @@ fn lint_filter_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, } /// lint use of `filter().map()` for `Iterators` -fn lint_filter_map_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, _filter_args: &'tcx [hir::Expr], _map_args: &'tcx [hir::Expr]) { +fn lint_filter_map_map<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + expr: &'tcx hir::Expr, + _filter_args: &'tcx [hir::Expr], + _map_args: &'tcx [hir::Expr], +) { // 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`. \ @@ -1317,7 +1335,12 @@ fn lint_filter_map_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Ex } /// lint use of `filter().flat_map()` for `Iterators` -fn lint_filter_flat_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, _filter_args: &'tcx [hir::Expr], _map_args: &'tcx [hir::Expr]) { +fn lint_filter_flat_map<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + expr: &'tcx hir::Expr, + _filter_args: &'tcx [hir::Expr], + _map_args: &'tcx [hir::Expr], +) { // 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`. \ @@ -1328,7 +1351,12 @@ fn lint_filter_flat_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::E } /// lint use of `filter_map().flat_map()` for `Iterators` -fn lint_filter_map_flat_map<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, _filter_args: &'tcx [hir::Expr], _map_args: &'tcx [hir::Expr]) { +fn lint_filter_map_flat_map<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + expr: &'tcx hir::Expr, + _filter_args: &'tcx [hir::Expr], + _map_args: &'tcx [hir::Expr], +) { // 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`. \ @@ -1399,7 +1427,13 @@ fn lint_binary_expr_with_method_call<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, i } /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_NEXT_CMP` lints. -fn lint_chars_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo, chain_methods: &[&str], lint: &'static Lint, suggest: &str) -> bool { +fn lint_chars_cmp<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + info: &BinaryExprInfo, + chain_methods: &[&str], + lint: &'static Lint, + suggest: &str, +) -> bool { if_let_chain! {[ let Some(args) = method_chain_args(info.chain, chain_methods), let hir::ExprCall(ref fun, ref arg_char) = info.other.node, @@ -1446,7 +1480,13 @@ fn lint_chars_last_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprIn } /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`. -fn lint_chars_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo, chain_methods: &[&str], lint: &'static Lint, suggest: &str) -> bool { +fn lint_chars_cmp_with_unwrap<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + info: &BinaryExprInfo, + chain_methods: &[&str], + lint: &'static Lint, + suggest: &str, +) -> bool { if_let_chain! {[ let Some(args) = method_chain_args(info.chain, chain_methods), let hir::ExprLit(ref lit) = info.other.node, @@ -1490,7 +1530,11 @@ fn lint_single_char_pattern<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hi let parent_item = cx.tcx.hir.get_parent(arg.id); let parent_def_id = cx.tcx.hir.local_def_id(parent_item); let substs = Substs::identity_for_item(cx.tcx, parent_def_id); - if let Ok(&ty::Const { val: ConstVal::Str(r), .. }) = ConstContext::new(cx.tcx, cx.param_env.and(substs), cx.tables).eval(arg) { + if let Ok(&ty::Const { + val: ConstVal::Str(r), + .. + }) = ConstContext::new(cx.tcx, cx.param_env.and(substs), cx.tables).eval(arg) + { if r.len() == 1 { let hint = snippet(cx, expr.span, "..").replace(&format!("\"{}\"", r), &format!("'{}'", r)); span_lint_and_then( @@ -1498,7 +1542,9 @@ fn lint_single_char_pattern<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hi SINGLE_CHAR_PATTERN, arg.span, "single-character string constant used as pattern", - |db| { db.span_suggestion(expr.span, "try using a char instead", hint); }, + |db| { + db.span_suggestion(expr.span, "try using a char instead", hint); + }, ); } } @@ -1669,27 +1715,24 @@ impl SelfKind { fn is_as_ref_or_mut_trait(ty: &hir::Ty, self_ty: &hir::Ty, generics: &hir::Generics, name: &[&str]) -> bool { single_segment_ty(ty).map_or(false, |seg| { generics.ty_params.iter().any(|param| { - param.name == seg.name && - param + param.name == seg.name + && param .bounds .iter() .any(|bound| if let hir::TyParamBound::TraitTyParamBound(ref ptr, ..) = *bound { let path = &ptr.trait_ref.path; - match_path(path, name) && - path.segments + match_path(path, name) + && path.segments .last() - .map_or(false, |s| { - if let Some(ref params) = s.parameters { - if params.parenthesized { - false - } else { - params.types.len() == 1 && - (is_self_ty(¶ms.types[0]) - || is_ty(&*params.types[0], self_ty)) - } - } else { + .map_or(false, |s| if let Some(ref params) = s.parameters { + if params.parenthesized { false + } else { + params.types.len() == 1 + && (is_self_ty(¶ms.types[0]) || is_ty(&*params.types[0], self_ty)) } + } else { + false }) } else { false diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs index 24adbe943e1..c13caf84b98 100644 --- a/tests/ui/methods.rs +++ b/tests/ui/methods.rs @@ -17,8 +17,11 @@ use std::sync::{self, Arc}; struct T; impl T { - fn add(self, other: T) -> T { self } - fn drop(&mut self) { } + pub fn add(self, other: T) -> T { self } + pub fn drop(&mut self) { } + + fn neg(self) -> Self { self } // no error, private function + fn eq(&self, other: T) -> bool { true } // no error, private function fn sub(&self, other: T) -> &T { self } // no error, self is a ref fn div(self) -> T { self } // no error, different #arguments diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr index 97e8c25ad75..9591d1f4fb4 100644 --- a/tests/ui/methods.stderr +++ b/tests/ui/methods.stderr @@ -1,471 +1,477 @@ error: unnecessary structure name repetition - --> $DIR/methods.rs:20:25 + --> $DIR/methods.rs:20:29 | -20 | fn add(self, other: T) -> T { self } - | ^ help: use the applicable keyword: `Self` +20 | pub fn add(self, other: T) -> T { self } + | ^ help: use the applicable keyword: `Self` | = note: `-D use-self` implied by `-D warnings` error: unnecessary structure name repetition - --> $DIR/methods.rs:20:31 + --> $DIR/methods.rs:20:35 | -20 | fn add(self, other: T) -> T { self } - | ^ help: use the applicable keyword: `Self` +20 | pub fn add(self, other: T) -> T { self } + | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:23:26 + --> $DIR/methods.rs:24:25 | -23 | fn sub(&self, other: T) -> &T { self } // no error, self is a ref +24 | fn eq(&self, other: T) -> bool { true } // no error, private function + | ^ help: use the applicable keyword: `Self` + +error: unnecessary structure name repetition + --> $DIR/methods.rs:26:26 + | +26 | fn sub(&self, other: T) -> &T { self } // no error, self is a ref | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:23:33 + --> $DIR/methods.rs:26:33 | -23 | fn sub(&self, other: T) -> &T { self } // no error, self is a ref +26 | fn sub(&self, other: T) -> &T { self } // no error, self is a ref | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:24:21 + --> $DIR/methods.rs:27:21 | -24 | fn div(self) -> T { self } // no error, different #arguments +27 | fn div(self) -> T { self } // no error, different #arguments | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:25:25 + --> $DIR/methods.rs:28:25 | -25 | fn rem(self, other: T) { } // no error, wrong return type +28 | fn rem(self, other: T) { } // no error, wrong return type | ^ help: use the applicable keyword: `Self` error: defining a method called `add` on this type; consider implementing the `std::ops::Add` trait or choosing a less ambiguous name --> $DIR/methods.rs:20:5 | -20 | fn add(self, other: T) -> T { self } - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +20 | pub fn add(self, other: T) -> T { self } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `-D should-implement-trait` implied by `-D warnings` error: defining a method called `drop` on this type; consider implementing the `std::ops::Drop` trait or choosing a less ambiguous name --> $DIR/methods.rs:21:5 | -21 | fn drop(&mut self) { } - | ^^^^^^^^^^^^^^^^^^^^^^ +21 | pub fn drop(&mut self) { } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name - --> $DIR/methods.rs:28:17 + --> $DIR/methods.rs:31:17 | -28 | fn into_u16(&self) -> u16 { 0 } +31 | fn into_u16(&self) -> u16 { 0 } | ^^^^^ | = note: `-D wrong-self-convention` implied by `-D warnings` error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name - --> $DIR/methods.rs:30:21 + --> $DIR/methods.rs:33:21 | -30 | fn to_something(self) -> u32 { 0 } +33 | fn to_something(self) -> u32 { 0 } | ^^^^ error: methods called `new` usually take no self; consider choosing a less ambiguous name - --> $DIR/methods.rs:32:12 + --> $DIR/methods.rs:35:12 | -32 | fn new(self) {} +35 | fn new(self) {} | ^^^^ error: methods called `new` usually return `Self` - --> $DIR/methods.rs:32:5 + --> $DIR/methods.rs:35:5 | -32 | fn new(self) {} +35 | fn new(self) {} | ^^^^^^^^^^^^^^^ | = note: `-D new-ret-no-self` implied by `-D warnings` error: unnecessary structure name repetition - --> $DIR/methods.rs:76:24 + --> $DIR/methods.rs:79:24 | -76 | fn new() -> Option> { None } +79 | fn new() -> Option> { None } | ^^^^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:80:19 + --> $DIR/methods.rs:83:19 | -80 | type Output = T; +83 | type Output = T; | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:81:25 + --> $DIR/methods.rs:84:25 | -81 | fn mul(self, other: T) -> T { self } // no error, obviously +84 | fn mul(self, other: T) -> T { self } // no error, obviously | ^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:81:31 + --> $DIR/methods.rs:84:31 | -81 | fn mul(self, other: T) -> T { self } // no error, obviously +84 | fn mul(self, other: T) -> T { self } // no error, obviously | ^ help: use the applicable keyword: `Self` error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead - --> $DIR/methods.rs:100:13 + --> $DIR/methods.rs:103:13 | -100 | let _ = opt.map(|x| x + 1) +103 | let _ = opt.map(|x| x + 1) | _____________^ -101 | | -102 | | .unwrap_or(0); // should lint even though this call is on a separate line +104 | | +105 | | .unwrap_or(0); // should lint even though this call is on a separate line | |____________________________^ | = note: `-D option-map-unwrap-or` implied by `-D warnings` = note: replace `map(|x| x + 1).unwrap_or(0)` with `map_or(0, |x| x + 1)` error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead - --> $DIR/methods.rs:104:13 + --> $DIR/methods.rs:107:13 | -104 | let _ = opt.map(|x| { +107 | let _ = opt.map(|x| { | _____________^ -105 | | x + 1 -106 | | } -107 | | ).unwrap_or(0); +108 | | x + 1 +109 | | } +110 | | ).unwrap_or(0); | |____________________________^ error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead - --> $DIR/methods.rs:108:13 + --> $DIR/methods.rs:111:13 | -108 | let _ = opt.map(|x| x + 1) +111 | let _ = opt.map(|x| x + 1) | _____________^ -109 | | .unwrap_or({ -110 | | 0 -111 | | }); +112 | | .unwrap_or({ +113 | | 0 +114 | | }); | |__________________^ error: called `map(f).unwrap_or(None)` on an Option value. This can be done more directly by calling `and_then(f)` instead - --> $DIR/methods.rs:113:13 + --> $DIR/methods.rs:116:13 | -113 | let _ = opt.map(|x| Some(x + 1)).unwrap_or(None); +116 | let _ = opt.map(|x| Some(x + 1)).unwrap_or(None); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: replace `map(|x| Some(x + 1)).unwrap_or(None)` with `and_then(|x| Some(x + 1))` error: called `map(f).unwrap_or(None)` on an Option value. This can be done more directly by calling `and_then(f)` instead - --> $DIR/methods.rs:115:13 + --> $DIR/methods.rs:118:13 | -115 | let _ = opt.map(|x| { +118 | let _ = opt.map(|x| { | _____________^ -116 | | Some(x + 1) -117 | | } -118 | | ).unwrap_or(None); +119 | | Some(x + 1) +120 | | } +121 | | ).unwrap_or(None); | |_____________________^ error: called `map(f).unwrap_or(None)` on an Option value. This can be done more directly by calling `and_then(f)` instead - --> $DIR/methods.rs:119:13 + --> $DIR/methods.rs:122:13 | -119 | let _ = opt +122 | let _ = opt | _____________^ -120 | | .map(|x| Some(x + 1)) -121 | | .unwrap_or(None); +123 | | .map(|x| Some(x + 1)) +124 | | .unwrap_or(None); | |________________________^ | = note: replace `map(|x| Some(x + 1)).unwrap_or(None)` with `and_then(|x| Some(x + 1))` error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead - --> $DIR/methods.rs:127:13 + --> $DIR/methods.rs:130:13 | -127 | let _ = opt.map(|x| x + 1) +130 | let _ = opt.map(|x| x + 1) | _____________^ -128 | | -129 | | .unwrap_or_else(|| 0); // should lint even though this call is on a separate line +131 | | +132 | | .unwrap_or_else(|| 0); // should lint even though this call is on a separate line | |____________________________________^ | = note: `-D option-map-unwrap-or-else` implied by `-D warnings` = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)` error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead - --> $DIR/methods.rs:131:13 + --> $DIR/methods.rs:134:13 | -131 | let _ = opt.map(|x| { +134 | let _ = opt.map(|x| { | _____________^ -132 | | x + 1 -133 | | } -134 | | ).unwrap_or_else(|| 0); +135 | | x + 1 +136 | | } +137 | | ).unwrap_or_else(|| 0); | |____________________________________^ error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead - --> $DIR/methods.rs:135:13 + --> $DIR/methods.rs:138:13 | -135 | let _ = opt.map(|x| x + 1) +138 | let _ = opt.map(|x| x + 1) | _____________^ -136 | | .unwrap_or_else(|| -137 | | 0 -138 | | ); +139 | | .unwrap_or_else(|| +140 | | 0 +141 | | ); | |_________________^ error: called `map_or(None, f)` on an Option value. This can be done more directly by calling `and_then(f)` instead - --> $DIR/methods.rs:144:13 + --> $DIR/methods.rs:147:13 | -144 | let _ = opt.map_or(None, |x| Some(x + 1)); +147 | let _ = opt.map_or(None, |x| Some(x + 1)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using and_then instead: `opt.and_then(|x| Some(x + 1))` | = note: `-D option-map-or-none` implied by `-D warnings` error: called `map_or(None, f)` on an Option value. This can be done more directly by calling `and_then(f)` instead - --> $DIR/methods.rs:146:13 + --> $DIR/methods.rs:149:13 | -146 | let _ = opt.map_or(None, |x| { +149 | let _ = opt.map_or(None, |x| { | _____________^ -147 | | Some(x + 1) -148 | | } -149 | | ); +150 | | Some(x + 1) +151 | | } +152 | | ); | |_________________^ | help: try using and_then instead | -146 | let _ = opt.and_then(|x| { -147 | Some(x + 1) -148 | }); +149 | let _ = opt.and_then(|x| { +150 | Some(x + 1) +151 | }); | error: unnecessary structure name repetition - --> $DIR/methods.rs:173:24 + --> $DIR/methods.rs:176:24 | -173 | fn filter(self) -> IteratorFalsePositives { +176 | fn filter(self) -> IteratorFalsePositives { | ^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:177:22 + --> $DIR/methods.rs:180:22 | -177 | fn next(self) -> IteratorFalsePositives { +180 | fn next(self) -> IteratorFalsePositives { | ^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self` error: unnecessary structure name repetition - --> $DIR/methods.rs:197:32 + --> $DIR/methods.rs:200:32 | -197 | fn skip(self, _: usize) -> IteratorFalsePositives { +200 | fn skip(self, _: usize) -> IteratorFalsePositives { | ^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self` error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead. - --> $DIR/methods.rs:207:13 + --> $DIR/methods.rs:210:13 | -207 | let _ = v.iter().filter(|&x| *x < 0).next(); +210 | let _ = v.iter().filter(|&x| *x < 0).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `-D filter-next` implied by `-D warnings` = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)` error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead. - --> $DIR/methods.rs:210:13 + --> $DIR/methods.rs:213:13 | -210 | let _ = v.iter().filter(|&x| { +213 | let _ = v.iter().filter(|&x| { | _____________^ -211 | | *x < 0 -212 | | } -213 | | ).next(); +214 | | *x < 0 +215 | | } +216 | | ).next(); | |___________________________^ error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:225:13 + --> $DIR/methods.rs:228:13 | -225 | let _ = v.iter().find(|&x| *x < 0).is_some(); +228 | let _ = v.iter().find(|&x| *x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `-D search-is-some` implied by `-D warnings` = note: replace `find(|&x| *x < 0).is_some()` with `any(|&x| *x < 0)` error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:228:13 + --> $DIR/methods.rs:231:13 | -228 | let _ = v.iter().find(|&x| { +231 | let _ = v.iter().find(|&x| { | _____________^ -229 | | *x < 0 -230 | | } -231 | | ).is_some(); +232 | | *x < 0 +233 | | } +234 | | ).is_some(); | |______________________________^ error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:234:13 + --> $DIR/methods.rs:237:13 | -234 | let _ = v.iter().position(|&x| x < 0).is_some(); +237 | let _ = v.iter().position(|&x| x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: replace `position(|&x| x < 0).is_some()` with `any(|&x| x < 0)` error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:237:13 + --> $DIR/methods.rs:240:13 | -237 | let _ = v.iter().position(|&x| { +240 | let _ = v.iter().position(|&x| { | _____________^ -238 | | x < 0 -239 | | } -240 | | ).is_some(); +241 | | x < 0 +242 | | } +243 | | ).is_some(); | |______________________________^ error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:243:13 + --> $DIR/methods.rs:246:13 | -243 | let _ = v.iter().rposition(|&x| x < 0).is_some(); +246 | let _ = v.iter().rposition(|&x| x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: replace `rposition(|&x| x < 0).is_some()` with `any(|&x| x < 0)` error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. - --> $DIR/methods.rs:246:13 + --> $DIR/methods.rs:249:13 | -246 | let _ = v.iter().rposition(|&x| { +249 | let _ = v.iter().rposition(|&x| { | _____________^ -247 | | x < 0 -248 | | } -249 | | ).is_some(); +250 | | x < 0 +251 | | } +252 | | ).is_some(); | |______________________________^ error: unnecessary structure name repetition - --> $DIR/methods.rs:263:21 + --> $DIR/methods.rs:266:21 | -263 | fn new() -> Foo { Foo } +266 | fn new() -> Foo { Foo } | ^^^ help: use the applicable keyword: `Self` error: use of `unwrap_or` followed by a function call - --> $DIR/methods.rs:281:5 + --> $DIR/methods.rs:284:5 | -281 | with_constructor.unwrap_or(make()); +284 | with_constructor.unwrap_or(make()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_constructor.unwrap_or_else(make)` | = note: `-D or-fun-call` implied by `-D warnings` error: use of `unwrap_or` followed by a call to `new` - --> $DIR/methods.rs:284:5 - | -284 | with_new.unwrap_or(Vec::new()); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_new.unwrap_or_default()` - -error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:287:5 | -287 | with_const_args.unwrap_or(Vec::with_capacity(12)); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_const_args.unwrap_or_else(|| Vec::with_capacity(12))` +287 | with_new.unwrap_or(Vec::new()); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_new.unwrap_or_default()` error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:290:5 | -290 | with_err.unwrap_or(make()); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_err.unwrap_or_else(|_| make())` +290 | with_const_args.unwrap_or(Vec::with_capacity(12)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_const_args.unwrap_or_else(|| Vec::with_capacity(12))` error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:293:5 | -293 | with_err_args.unwrap_or(Vec::with_capacity(12)); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_err_args.unwrap_or_else(|_| Vec::with_capacity(12))` +293 | with_err.unwrap_or(make()); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_err.unwrap_or_else(|_| make())` -error: use of `unwrap_or` followed by a call to `default` +error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:296:5 | -296 | with_default_trait.unwrap_or(Default::default()); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_trait.unwrap_or_default()` +296 | with_err_args.unwrap_or(Vec::with_capacity(12)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_err_args.unwrap_or_else(|_| Vec::with_capacity(12))` error: use of `unwrap_or` followed by a call to `default` --> $DIR/methods.rs:299:5 | -299 | with_default_type.unwrap_or(u64::default()); +299 | with_default_trait.unwrap_or(Default::default()); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_trait.unwrap_or_default()` + +error: use of `unwrap_or` followed by a call to `default` + --> $DIR/methods.rs:302:5 + | +302 | with_default_type.unwrap_or(u64::default()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_type.unwrap_or_default()` error: use of `unwrap_or` followed by a function call - --> $DIR/methods.rs:302:5 + --> $DIR/methods.rs:305:5 | -302 | with_vec.unwrap_or(vec![]); +305 | with_vec.unwrap_or(vec![]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_vec.unwrap_or_else(|| < [ _ ] > :: into_vec ( box [ $ ( $ x ) , * ] ))` error: use of `unwrap_or` followed by a function call - --> $DIR/methods.rs:307:5 - | -307 | without_default.unwrap_or(Foo::new()); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `without_default.unwrap_or_else(Foo::new)` - -error: use of `or_insert` followed by a function call --> $DIR/methods.rs:310:5 | -310 | map.entry(42).or_insert(String::new()); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `map.entry(42).or_insert_with(String::new)` +310 | without_default.unwrap_or(Foo::new()); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `without_default.unwrap_or_else(Foo::new)` error: use of `or_insert` followed by a function call --> $DIR/methods.rs:313:5 | -313 | btree.entry(42).or_insert(String::new()); +313 | map.entry(42).or_insert(String::new()); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `map.entry(42).or_insert_with(String::new)` + +error: use of `or_insert` followed by a function call + --> $DIR/methods.rs:316:5 + | +316 | btree.entry(42).or_insert(String::new()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `btree.entry(42).or_insert_with(String::new)` error: use of `unwrap_or` followed by a function call - --> $DIR/methods.rs:316:13 + --> $DIR/methods.rs:319:13 | -316 | let _ = stringy.unwrap_or("".to_owned()); +319 | let _ = stringy.unwrap_or("".to_owned()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `stringy.unwrap_or_else(|| "".to_owned())` error: called `.iter().nth()` on a Vec. Calling `.get()` is both faster and more readable - --> $DIR/methods.rs:327:23 + --> $DIR/methods.rs:330:23 | -327 | let bad_vec = some_vec.iter().nth(3); +330 | let bad_vec = some_vec.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: `-D iter-nth` implied by `-D warnings` error: called `.iter().nth()` on a slice. Calling `.get()` is both faster and more readable - --> $DIR/methods.rs:328:26 + --> $DIR/methods.rs:331:26 | -328 | let bad_slice = &some_vec[..].iter().nth(3); +331 | let bad_slice = &some_vec[..].iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `.iter().nth()` on a slice. Calling `.get()` is both faster and more readable - --> $DIR/methods.rs:329:31 + --> $DIR/methods.rs:332:31 | -329 | let bad_boxed_slice = boxed_slice.iter().nth(3); +332 | let bad_boxed_slice = boxed_slice.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `.iter().nth()` on a VecDeque. Calling `.get()` is both faster and more readable - --> $DIR/methods.rs:330:29 + --> $DIR/methods.rs:333:29 | -330 | let bad_vec_deque = some_vec_deque.iter().nth(3); +333 | let bad_vec_deque = some_vec_deque.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `.iter_mut().nth()` on a Vec. Calling `.get_mut()` is both faster and more readable - --> $DIR/methods.rs:335:23 + --> $DIR/methods.rs:338:23 | -335 | let bad_vec = some_vec.iter_mut().nth(3); +338 | let bad_vec = some_vec.iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `.iter_mut().nth()` on a slice. Calling `.get_mut()` is both faster and more readable - --> $DIR/methods.rs:338:26 + --> $DIR/methods.rs:341:26 | -338 | let bad_slice = &some_vec[..].iter_mut().nth(3); +341 | let bad_slice = &some_vec[..].iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `.iter_mut().nth()` on a VecDeque. Calling `.get_mut()` is both faster and more readable - --> $DIR/methods.rs:341:29 + --> $DIR/methods.rs:344:29 | -341 | let bad_vec_deque = some_vec_deque.iter_mut().nth(3); +344 | let bad_vec_deque = some_vec_deque.iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` - --> $DIR/methods.rs:353:13 + --> $DIR/methods.rs:356:13 | -353 | let _ = some_vec.iter().skip(42).next(); +356 | let _ = some_vec.iter().skip(42).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `-D iter-skip-next` implied by `-D warnings` error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` - --> $DIR/methods.rs:354:13 + --> $DIR/methods.rs:357:13 | -354 | let _ = some_vec.iter().cycle().skip(42).next(); +357 | let _ = some_vec.iter().cycle().skip(42).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` - --> $DIR/methods.rs:355:13 + --> $DIR/methods.rs:358:13 | -355 | let _ = (1..10).skip(10).next(); +358 | let _ = (1..10).skip(10).next(); | ^^^^^^^^^^^^^^^^^^^^^^^ error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` - --> $DIR/methods.rs:356:14 + --> $DIR/methods.rs:359:14 | -356 | let _ = &some_vec[..].iter().skip(3).next(); +359 | let _ = &some_vec[..].iter().skip(3).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: used unwrap() on an Option value. If you don't want to handle the None case gracefully, consider using expect() to provide a better panic message - --> $DIR/methods.rs:365:13 + --> $DIR/methods.rs:368:13 | -365 | let _ = opt.unwrap(); +368 | let _ = opt.unwrap(); | ^^^^^^^^^^^^ | = note: `-D option-unwrap-used` implied by `-D warnings`