/// 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:**
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));
+ }
}
}
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, "_")),
);
-
}
}
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,
// 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",
}
/// 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
/// 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 {
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);
+ });
}
}
}
}
/// 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`. \
}
/// 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`. \
}
/// 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`. \
}
/// 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`. \
}
/// 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,
}
/// 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,
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(
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);
+ },
);
}
}
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
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:24:25
+ |
+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:23:26
+ --> $DIR/methods.rs:26:26
|
-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: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<V<T>> { None }
+79 | fn new() -> Option<V<T>> { 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
+ --> $DIR/methods.rs:287:5
|
-284 | with_new.unwrap_or(Vec::new());
+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:287:5
+ --> $DIR/methods.rs:290:5
|
-287 | with_const_args.unwrap_or(Vec::with_capacity(12));
+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:290:5
+ --> $DIR/methods.rs:293:5
|
-290 | with_err.unwrap_or(make());
+293 | with_err.unwrap_or(make());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_err.unwrap_or_else(|_| make())`
error: use of `unwrap_or` followed by a function call
- --> $DIR/methods.rs:293:5
+ --> $DIR/methods.rs:296:5
|
-293 | with_err_args.unwrap_or(Vec::with_capacity(12));
+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:296:5
+ --> $DIR/methods.rs:299:5
|
-296 | with_default_trait.unwrap_or(Default::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:299:5
+ --> $DIR/methods.rs:302:5
|
-299 | with_default_type.unwrap_or(u64::default());
+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
+ --> $DIR/methods.rs:310:5
|
-307 | without_default.unwrap_or(Foo::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:310:5
+ --> $DIR/methods.rs:313:5
|
-310 | map.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:313:5
+ --> $DIR/methods.rs:316:5
|
-313 | btree.entry(42).or_insert(String::new());
+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`
projects / rust.git / commitdiff