3 use rustc
::middle
::const_val
::ConstVal
;
4 use rustc
::ty
::{self, Ty}
;
5 use rustc
::hir
::def
::Def
;
6 use rustc
::ty
::subst
::Substs
;
7 use rustc_const_eval
::ConstContext
;
12 use syntax
::codemap
::{Span, BytePos}
;
13 use utils
::{get_arg_name
, get_trait_def_id
, implements_trait
, in_external_macro
, in_macro
, is_copy
, is_self
, is_self_ty
,
14 iter_input_pats
, last_path_segment
, match_def_path
, match_path
, match_qpath
, match_trait_method
,
15 match_type
, method_chain_args
, match_var
, return_ty
, remove_blocks
, same_tys
, single_segment_path
, snippet
,
16 span_lint
, span_lint_and_sugg
, span_lint_and_then
, span_note_and_lint
, walk_ptrs_ty
, walk_ptrs_ty_depth
};
19 use utils
::const_to_u64
;
24 /// **What it does:** Checks for `.unwrap()` calls on `Option`s.
26 /// **Why is this bad?** Usually it is better to handle the `None` case, or to
27 /// at least call `.expect(_)` with a more helpful message. Still, for a lot of
28 /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
29 /// `Allow` by default.
31 /// **Known problems:** None.
38 pub OPTION_UNWRAP_USED
,
40 "using `Option.unwrap()`, which should at least get a better message using `expect()`"
43 /// **What it does:** Checks for `.unwrap()` calls on `Result`s.
45 /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err`
46 /// values. Normally, you want to implement more sophisticated error handling,
47 /// and propagate errors upwards with `try!`.
49 /// Even if you want to panic on errors, not all `Error`s implement good
50 /// messages on display. Therefore it may be beneficial to look at the places
51 /// where they may get displayed. Activate this lint to do just that.
53 /// **Known problems:** None.
60 pub RESULT_UNWRAP_USED
,
62 "using `Result.unwrap()`, which might be better handled"
65 /// **What it does:** Checks for methods that should live in a trait
66 /// implementation of a `std` trait (see [llogiq's blog
67 /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
68 /// information) instead of an inherent implementation.
70 /// **Why is this bad?** Implementing the traits improve ergonomics for users of
71 /// the code, often with very little cost. Also people seeing a `mul(...)`
73 /// may expect `*` to work equally, so you should have good reason to disappoint
76 /// **Known problems:** None.
82 /// fn add(&self, other: &X) -> X { .. }
86 pub SHOULD_IMPLEMENT_TRAIT
,
88 "defining a method that should be implementing a std trait"
91 /// **What it does:** Checks for methods with certain name prefixes and which
92 /// doesn't match how self is taken. The actual rules are:
94 /// |Prefix |`self` taken |
95 /// |-------|----------------------|
96 /// |`as_` |`&self` or `&mut self`|
99 /// |`is_` |`&self` or none |
100 /// |`to_` |`&self` |
102 /// **Why is this bad?** Consistency breeds readability. If you follow the
103 /// conventions, your users won't be surprised that they, e.g., need to supply a
104 /// mutable reference to a `as_..` function.
106 /// **Known problems:** None.
111 /// fn as_str(self) -> &str { .. }
115 pub WRONG_SELF_CONVENTION
,
117 "defining a method named with an established prefix (like \"into_\") that takes \
118 `self` with the wrong convention"
121 /// **What it does:** This is the same as
122 /// [`wrong_self_convention`](#wrong_self_convention), but for public items.
124 /// **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).
126 /// **Known problems:** Actually *renaming* the function may break clients if
127 /// the function is part of the public interface. In that case, be mindful of
128 /// the stability guarantees you've given your users.
133 /// pub fn as_str(self) -> &str { .. }
137 pub WRONG_PUB_SELF_CONVENTION
,
139 "defining a public method named with an established prefix (like \"into_\") that takes \
140 `self` with the wrong convention"
143 /// **What it does:** Checks for usage of `ok().expect(..)`.
145 /// **Why is this bad?** Because you usually call `expect()` on the `Result`
146 /// directly to get a better error message.
148 /// **Known problems:** None.
152 /// x.ok().expect("why did I do this again?")
157 "using `ok().expect()`, which gives worse error messages than \
158 calling `expect` directly on the Result"
161 /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`.
163 /// **Why is this bad?** Readability, this can be written more concisely as
164 /// `_.map_or(_, _)`.
166 /// **Known problems:** None.
170 /// x.map(|a| a + 1).unwrap_or(0)
173 pub OPTION_MAP_UNWRAP_OR
,
175 "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \
179 /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`.
181 /// **Why is this bad?** Readability, this can be written more concisely as
182 /// `_.map_or_else(_, _)`.
184 /// **Known problems:** None.
188 /// x.map(|a| a + 1).unwrap_or_else(some_function)
191 pub OPTION_MAP_UNWRAP_OR_ELSE
,
193 "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \
197 /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`.
199 /// **Why is this bad?** Readability, this can be written more concisely as
200 /// `result.ok().map_or_else(_, _)`.
202 /// **Known problems:** None.
206 /// x.map(|a| a + 1).unwrap_or_else(some_function)
209 pub RESULT_MAP_UNWRAP_OR_ELSE
,
211 "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \
212 `.ok().map_or_else(g, f)`"
215 /// **What it does:** Checks for usage of `_.map_or(None, _)`.
217 /// **Why is this bad?** Readability, this can be written more concisely as
220 /// **Known problems:** None.
224 /// opt.map_or(None, |a| a + 1)
227 pub OPTION_MAP_OR_NONE
,
229 "using `Option.map_or(None, f)`, which is more succinctly expressed as \
233 /// **What it does:** Checks for usage of `_.filter(_).next()`.
235 /// **Why is this bad?** Readability, this can be written more concisely as
238 /// **Known problems:** None.
242 /// iter.filter(|x| x == 0).next()
247 "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
250 /// **What it does:** Checks for usage of `_.filter(_).map(_)`,
251 /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.
253 /// **Why is this bad?** Readability, this can be written more concisely as a
254 /// single method call.
256 /// **Known problems:** Often requires a condition + Option/Iterator creation
257 /// inside the closure.
261 /// iter.filter(|x| x == 0).map(|x| x * 2)
266 "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can \
267 usually be written as a single method call"
270 /// **What it does:** Checks for an iterator search (such as `find()`,
271 /// `position()`, or `rposition()`) followed by a call to `is_some()`.
273 /// **Why is this bad?** Readability, this can be written more concisely as
276 /// **Known problems:** None.
280 /// iter.find(|x| x == 0).is_some()
285 "using an iterator search followed by `is_some()`, which is more succinctly \
286 expressed as a call to `any()`"
289 /// **What it does:** Checks for usage of `.chars().next()` on a `str` to check
290 /// if it starts with a given char.
292 /// **Why is this bad?** Readability, this can be written more concisely as
293 /// `_.starts_with(_)`.
295 /// **Known problems:** None.
299 /// name.chars().next() == Some('_')
304 "using `.chars().next()` to check if a string starts with a char"
307 /// **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
308 /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
309 /// `unwrap_or_default` instead.
311 /// **Why is this bad?** The function will always be called and potentially
312 /// allocate an object acting as the default.
314 /// **Known problems:** If the function has side-effects, not calling it will
315 /// change the semantic of the program, but you shouldn't rely on that anyway.
319 /// foo.unwrap_or(String::new())
321 /// this can instead be written:
323 /// foo.unwrap_or_else(String::new)
327 /// foo.unwrap_or_default()
332 "using any `*or` method with a function call, which suggests `*or_else`"
335 /// **What it does:** Checks for usage of `.clone()` on a `Copy` type.
337 /// **Why is this bad?** The only reason `Copy` types implement `Clone` is for
338 /// generics, not for using the `clone` method on a concrete type.
340 /// **Known problems:** None.
349 "using `clone` on a `Copy` type"
352 /// **What it does:** Checks for usage of `.clone()` on a ref-counted pointer,
353 /// (Rc, Arc, rc::Weak, or sync::Weak), and suggests calling Clone on
354 /// the corresponding trait instead.
356 /// **Why is this bad?**: Calling '.clone()' on an Rc, Arc, or Weak
357 /// can obscure the fact that only the pointer is being cloned, not the underlying
364 declare_restriction_lint
! {
365 pub CLONE_ON_REF_PTR
,
366 "using 'clone' on a ref-counted pointer"
369 /// **What it does:** Checks for usage of `.clone()` on an `&&T`.
371 /// **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of
372 /// cloning the underlying `T`.
374 /// **Known problems:** None.
381 /// let z = y.clone();
382 /// println!("{:p} {:p}",*y, z); // prints out the same pointer
386 pub CLONE_DOUBLE_REF
,
388 "using `clone` on `&&T`"
391 /// **What it does:** Checks for `new` not returning `Self`.
393 /// **Why is this bad?** As a convention, `new` methods are used to make a new
394 /// instance of a type.
396 /// **Known problems:** None.
401 /// fn new(..) -> NotAFoo {
408 "not returning `Self` in a `new` method"
411 /// **What it does:** Checks for string methods that receive a single-character
412 /// `str` as an argument, e.g. `_.split("x")`.
414 /// **Why is this bad?** Performing these methods using a `char` is faster than
417 /// **Known problems:** Does not catch multi-byte unicode characters.
420 /// `_.split("x")` could be `_.split('x')
422 pub SINGLE_CHAR_PATTERN
,
424 "using a single-character str where a char could be used, e.g. \
428 /// **What it does:** Checks for getting the inner pointer of a temporary
431 /// **Why is this bad?** The inner pointer of a `CString` is only valid as long
432 /// as the `CString` is alive.
434 /// **Known problems:** None.
438 /// let c_str = CString::new("foo").unwrap().as_ptr();
440 /// call_some_ffi_func(c_str);
443 /// Here `c_str` point to a freed address. The correct use would be:
445 /// let c_str = CString::new("foo").unwrap();
447 /// call_some_ffi_func(c_str.as_ptr());
451 pub TEMPORARY_CSTRING_AS_PTR
,
453 "getting the inner pointer of a temporary `CString`"
456 /// **What it does:** Checks for use of `.iter().nth()` (and the related
457 /// `.iter_mut().nth()`) on standard library types with O(1) element access.
459 /// **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more
462 /// **Known problems:** None.
466 /// let some_vec = vec![0, 1, 2, 3];
467 /// let bad_vec = some_vec.iter().nth(3);
468 /// let bad_slice = &some_vec[..].iter().nth(3);
470 /// The correct use would be:
472 /// let some_vec = vec![0, 1, 2, 3];
473 /// let bad_vec = some_vec.get(3);
474 /// let bad_slice = &some_vec[..].get(3);
479 "using `.iter().nth()` on a standard library type with O(1) element access"
482 /// **What it does:** Checks for use of `.skip(x).next()` on iterators.
484 /// **Why is this bad?** `.nth(x)` is cleaner
486 /// **Known problems:** None.
490 /// let some_vec = vec![0, 1, 2, 3];
491 /// let bad_vec = some_vec.iter().skip(3).next();
492 /// let bad_slice = &some_vec[..].iter().skip(3).next();
494 /// The correct use would be:
496 /// let some_vec = vec![0, 1, 2, 3];
497 /// let bad_vec = some_vec.iter().nth(3);
498 /// let bad_slice = &some_vec[..].iter().nth(3);
503 "using `.skip(x).next()` on an iterator"
506 /// **What it does:** Checks for use of `.get().unwrap()` (or
507 /// `.get_mut().unwrap`) on a standard library type which implements `Index`
509 /// **Why is this bad?** Using the Index trait (`[]`) is more clear and more
512 /// **Known problems:** None.
516 /// let some_vec = vec![0, 1, 2, 3];
517 /// let last = some_vec.get(3).unwrap();
518 /// *some_vec.get_mut(0).unwrap() = 1;
520 /// The correct use would be:
522 /// let some_vec = vec![0, 1, 2, 3];
523 /// let last = some_vec[3];
529 "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
532 /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a
533 /// `&str` or `String`.
535 /// **Why is this bad?** `.push_str(s)` is clearer
537 /// **Known problems:** None.
542 /// let def = String::from("def");
543 /// let mut s = String::new();
544 /// s.extend(abc.chars());
545 /// s.extend(def.chars());
547 /// The correct use would be:
550 /// let def = String::from("def");
551 /// let mut s = String::new();
553 /// s.push_str(&def));
556 pub STRING_EXTEND_CHARS
,
558 "using `x.extend(s.chars())` where s is a `&str` or `String`"
561 /// **What it does:** Checks for the use of `.cloned().collect()` on slice to
564 /// **Why is this bad?** `.to_vec()` is clearer
566 /// **Known problems:** None.
570 /// let s = [1,2,3,4,5];
571 /// let s2 : Vec<isize> = s[..].iter().cloned().collect();
573 /// The better use would be:
575 /// let s = [1,2,3,4,5];
576 /// let s2 : Vec<isize> = s.to_vec();
579 pub ITER_CLONED_COLLECT
,
581 "using `.cloned().collect()` on slice to create a `Vec`"
584 /// **What it does:** Checks for usage of `.chars().last()` or
585 /// `.chars().next_back()` on a `str` to check if it ends with a given char.
587 /// **Why is this bad?** Readability, this can be written more concisely as
588 /// `_.ends_with(_)`.
590 /// **Known problems:** None.
594 /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-')
599 "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
602 /// **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the
603 /// types before and after the call are the same.
605 /// **Why is this bad?** The call is unnecessary.
607 /// **Known problems:** None.
611 /// let x: &[i32] = &[1,2,3,4,5];
612 /// do_stuff(x.as_ref());
614 /// The correct use would be:
616 /// let x: &[i32] = &[1,2,3,4,5];
622 "using `as_ref` where the types before and after the call are the same"
626 /// **What it does:** Checks for using `fold` when a more succinct alternative exists.
627 /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
628 /// `sum` or `product`.
630 /// **Why is this bad?** Readability.
632 /// **Known problems:** None.
636 /// let _ = (0..3).fold(false, |acc, x| acc || x > 2);
638 /// This could be written as:
640 /// let _ = (0..3).any(|x| x > 2);
643 pub UNNECESSARY_FOLD
,
645 "using `fold` when a more succinct alternative exists"
648 impl LintPass
for Pass
{
649 fn get_lints(&self) -> LintArray
{
653 SHOULD_IMPLEMENT_TRAIT
,
654 WRONG_SELF_CONVENTION
,
655 WRONG_PUB_SELF_CONVENTION
,
657 OPTION_MAP_UNWRAP_OR
,
658 OPTION_MAP_UNWRAP_OR_ELSE
,
659 RESULT_MAP_UNWRAP_OR_ELSE
,
670 TEMPORARY_CSTRING_AS_PTR
,
684 impl<'a
, 'tcx
> LateLintPass
<'a
, 'tcx
> for Pass
{
685 #[allow(unused_attributes)]
686 // ^ required because `cyclomatic_complexity` attribute shows up as unused
687 #[cyclomatic_complexity = "30"]
688 fn check_expr(&mut self, cx
: &LateContext
<'a
, 'tcx
>, expr
: &'tcx hir
::Expr
) {
689 if in_macro(expr
.span
) {
694 hir
::ExprMethodCall(ref method_call
, _
, ref args
) => {
696 // GET_UNWRAP needs to be checked before general `UNWRAP` lints
697 if let Some(arglists
) = method_chain_args(expr
, &["get", "unwrap"]) {
698 lint_get_unwrap(cx
, expr
, arglists
[0], false);
699 } else if let Some(arglists
) = method_chain_args(expr
, &["get_mut", "unwrap"]) {
700 lint_get_unwrap(cx
, expr
, arglists
[0], true);
701 } else if let Some(arglists
) = method_chain_args(expr
, &["unwrap"]) {
702 lint_unwrap(cx
, expr
, arglists
[0]);
703 } else if let Some(arglists
) = method_chain_args(expr
, &["ok", "expect"]) {
704 lint_ok_expect(cx
, expr
, arglists
[0]);
705 } else if let Some(arglists
) = method_chain_args(expr
, &["map", "unwrap_or"]) {
706 lint_map_unwrap_or(cx
, expr
, arglists
[0], arglists
[1]);
707 } else if let Some(arglists
) = method_chain_args(expr
, &["map", "unwrap_or_else"]) {
708 lint_map_unwrap_or_else(cx
, expr
, arglists
[0], arglists
[1]);
709 } else if let Some(arglists
) = method_chain_args(expr
, &["map_or"]) {
710 lint_map_or_none(cx
, expr
, arglists
[0]);
711 } else if let Some(arglists
) = method_chain_args(expr
, &["filter", "next"]) {
712 lint_filter_next(cx
, expr
, arglists
[0]);
713 } else if let Some(arglists
) = method_chain_args(expr
, &["filter", "map"]) {
714 lint_filter_map(cx
, expr
, arglists
[0], arglists
[1]);
715 } else if let Some(arglists
) = method_chain_args(expr
, &["filter_map", "map"]) {
716 lint_filter_map_map(cx
, expr
, arglists
[0], arglists
[1]);
717 } else if let Some(arglists
) = method_chain_args(expr
, &["filter", "flat_map"]) {
718 lint_filter_flat_map(cx
, expr
, arglists
[0], arglists
[1]);
719 } else if let Some(arglists
) = method_chain_args(expr
, &["filter_map", "flat_map"]) {
720 lint_filter_map_flat_map(cx
, expr
, arglists
[0], arglists
[1]);
721 } else if let Some(arglists
) = method_chain_args(expr
, &["find", "is_some"]) {
722 lint_search_is_some(cx
, expr
, "find", arglists
[0], arglists
[1]);
723 } else if let Some(arglists
) = method_chain_args(expr
, &["position", "is_some"]) {
724 lint_search_is_some(cx
, expr
, "position", arglists
[0], arglists
[1]);
725 } else if let Some(arglists
) = method_chain_args(expr
, &["rposition", "is_some"]) {
726 lint_search_is_some(cx
, expr
, "rposition", arglists
[0], arglists
[1]);
727 } else if let Some(arglists
) = method_chain_args(expr
, &["extend"]) {
728 lint_extend(cx
, expr
, arglists
[0]);
729 } else if let Some(arglists
) = method_chain_args(expr
, &["unwrap", "as_ptr"]) {
730 lint_cstring_as_ptr(cx
, expr
, &arglists
[0][0], &arglists
[1][0]);
731 } else if let Some(arglists
) = method_chain_args(expr
, &["iter", "nth"]) {
732 lint_iter_nth(cx
, expr
, arglists
[0], false);
733 } else if let Some(arglists
) = method_chain_args(expr
, &["iter_mut", "nth"]) {
734 lint_iter_nth(cx
, expr
, arglists
[0], true);
735 } else if method_chain_args(expr
, &["skip", "next"]).is_some() {
736 lint_iter_skip_next(cx
, expr
);
737 } else if let Some(arglists
) = method_chain_args(expr
, &["cloned", "collect"]) {
738 lint_iter_cloned_collect(cx
, expr
, arglists
[0]);
739 } else if let Some(arglists
) = method_chain_args(expr
, &["as_ref"]) {
740 lint_asref(cx
, expr
, "as_ref", arglists
[0]);
741 } else if let Some(arglists
) = method_chain_args(expr
, &["as_mut"]) {
742 lint_asref(cx
, expr
, "as_mut", arglists
[0]);
743 } else if let Some(arglists
) = method_chain_args(expr
, &["fold"]) {
744 lint_unnecessary_fold(cx
, expr
, arglists
[0]);
747 lint_or_fun_call(cx
, expr
, &method_call
.name
.as_str(), args
);
749 let self_ty
= cx
.tables
.expr_ty_adjusted(&args
[0]);
750 if args
.len() == 1 && method_call
.name
== "clone" {
751 lint_clone_on_copy(cx
, expr
, &args
[0], self_ty
);
752 lint_clone_on_ref_ptr(cx
, expr
, &args
[0]);
756 ty
::TyRef(_
, ty
) if ty
.ty
.sty
== ty
::TyStr
=> for &(method
, pos
) in &PATTERN_METHODS
{
757 if method_call
.name
== method
&& args
.len() > pos
{
758 lint_single_char_pattern(cx
, expr
, &args
[pos
]);
764 hir
::ExprBinary(op
, ref lhs
, ref rhs
) if op
.node
== hir
::BiEq
|| op
.node
== hir
::BiNe
=> {
765 let mut info
= BinaryExprInfo
{
769 eq
: op
.node
== hir
::BiEq
,
771 lint_binary_expr_with_method_call(cx
, &mut info
);
777 fn check_impl_item(&mut self, cx
: &LateContext
<'a
, 'tcx
>, implitem
: &'tcx hir
::ImplItem
) {
778 if in_external_macro(cx
, implitem
.span
) {
781 let name
= implitem
.name
;
782 let parent
= cx
.tcx
.hir
.get_parent(implitem
.id
);
783 let item
= cx
.tcx
.hir
.expect_item(parent
);
785 if let hir
::ImplItemKind
::Method(ref sig
, id
) = implitem
.node
;
786 if let Some(first_arg_ty
) = sig
.decl
.inputs
.get(0);
787 if let Some(first_arg
) = iter_input_pats(&sig
.decl
, cx
.tcx
.hir
.body(id
)).next();
788 if let hir
::ItemImpl(_
, _
, _
, _
, None
, ref self_ty
, _
) = item
.node
;
790 if cx
.access_levels
.is_exported(implitem
.id
) {
791 // check missing trait implementations
792 for &(method_name
, n_args
, self_kind
, out_type
, trait_name
) in &TRAIT_METHODS
{
793 if name
== method_name
&&
794 sig
.decl
.inputs
.len() == n_args
&&
795 out_type
.matches(&sig
.decl
.output
) &&
796 self_kind
.matches(first_arg_ty
, first_arg
, self_ty
, false, &implitem
.generics
) {
797 span_lint(cx
, SHOULD_IMPLEMENT_TRAIT
, implitem
.span
, &format
!(
798 "defining a method called `{}` on this type; consider implementing \
799 the `{}` trait or choosing a less ambiguous name", name
, trait_name
));
804 // check conventions w.r.t. conversion method names and predicates
805 let def_id
= cx
.tcx
.hir
.local_def_id(item
.id
);
806 let ty
= cx
.tcx
.type_of(def_id
);
807 let is_copy
= is_copy(cx
, ty
);
808 for &(ref conv
, self_kinds
) in &CONVENTIONS
{
810 if conv
.check(&name
.as_str());
813 .any(|k
| k
.matches(first_arg_ty
, first_arg
, self_ty
, is_copy
, &implitem
.generics
));
815 let lint
= if item
.vis
== hir
::Visibility
::Public
{
816 WRONG_PUB_SELF_CONVENTION
818 WRONG_SELF_CONVENTION
823 &format
!("methods called `{}` usually take {}; consider choosing a less \
827 .map(|k
| k
.description())
834 let ret_ty
= return_ty(cx
, implitem
.id
);
836 !ret_ty
.walk().any(|t
| same_tys(cx
, t
, ty
)) {
840 "methods called `new` usually return `Self`");
847 /// Checks for the `OR_FUN_CALL` lint.
848 fn lint_or_fun_call(cx
: &LateContext
, expr
: &hir
::Expr
, name
: &str, args
: &[hir
::Expr
]) {
849 /// Check for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
850 fn check_unwrap_or_default(
854 self_expr
: &hir
::Expr
,
863 if name
== "unwrap_or" {
864 if let hir
::ExprPath(ref qpath
) = fun
.node
{
865 let path
= &*last_path_segment(qpath
).name
.as_str();
867 if ["default", "new"].contains(&path
) {
868 let arg_ty
= cx
.tables
.expr_ty(arg
);
869 let default_trait_id
= if let Some(default_trait_id
) = get_trait_def_id(cx
, &paths
::DEFAULT_TRAIT
) {
875 if implements_trait(cx
, arg_ty
, default_trait_id
, &[]) {
880 &format
!("use of `{}` followed by a call to `{}`", name
, path
),
882 format
!("{}.unwrap_or_default()", snippet(cx
, self_expr
.span
, "_")),
893 /// Check for `*or(foo())`.
894 fn check_general_case(
898 self_expr
: &hir
::Expr
,
903 // (path, fn_has_argument, methods, suffix)
904 let know_types
: &[(&[_
], _
, &[_
], _
)] = &[
905 (&paths
::BTREEMAP_ENTRY
, false, &["or_insert"], "with"),
906 (&paths
::HASHMAP_ENTRY
, false, &["or_insert"], "with"),
907 (&paths
::OPTION
, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
908 (&paths
::RESULT
, true, &["or", "unwrap_or"], "else"),
911 // early check if the name is one we care about
912 if know_types
.iter().all(|k
| !k
.2.contains(&name
)) {
916 // don't lint for constant values
917 let owner_def
= cx
.tcx
.hir
.get_parent_did(arg
.id
);
918 let promotable
= cx
.tcx
.rvalue_promotable_map(owner_def
).contains(&arg
.hir_id
.local_id
);
923 let self_ty
= cx
.tables
.expr_ty(self_expr
);
925 let (fn_has_arguments
, poss
, suffix
) = if let Some(&(_
, fn_has_arguments
, poss
, suffix
)) =
926 know_types
.iter().find(|&&i
| match_type(cx
, self_ty
, i
.0))
928 (fn_has_arguments
, poss
, suffix
)
933 if !poss
.contains(&name
) {
937 let sugg
: Cow
<_
> = match (fn_has_arguments
, !or_has_args
) {
938 (true, _
) => format
!("|_| {}", snippet(cx
, arg
.span
, "..")).into(),
939 (false, false) => format
!("|| {}", snippet(cx
, arg
.span
, "..")).into(),
940 (false, true) => snippet(cx
, fun_span
, ".."),
947 &format
!("use of `{}` followed by a function call", name
),
949 format
!("{}.{}_{}({})", snippet(cx
, self_expr
.span
, "_"), name
, suffix
, sugg
),
955 hir
::ExprCall(ref fun
, ref or_args
) => {
956 let or_has_args
= !or_args
.is_empty();
957 if !check_unwrap_or_default(cx
, name
, fun
, &args
[0], &args
[1], or_has_args
, expr
.span
) {
958 check_general_case(cx
, name
, fun
.span
, &args
[0], &args
[1], or_has_args
, expr
.span
);
961 hir
::ExprMethodCall(_
, span
, ref or_args
) => {
962 check_general_case(cx
, name
, span
, &args
[0], &args
[1], !or_args
.is_empty(), expr
.span
)
969 /// Checks for the `CLONE_ON_COPY` lint.
970 fn lint_clone_on_copy(cx
: &LateContext
, expr
: &hir
::Expr
, arg
: &hir
::Expr
, arg_ty
: Ty
) {
971 let ty
= cx
.tables
.expr_ty(expr
);
972 if let ty
::TyRef(_
, ty
::TypeAndMut { ty: inner, .. }
) = arg_ty
.sty
{
973 if let ty
::TyRef(_
, ty
::TypeAndMut { ty: innermost, .. }
) = inner
.sty
{
978 "using `clone` on a double-reference; \
979 this will copy the reference instead of cloning the inner type",
980 |db
| if let Some(snip
) = sugg
::Sugg
::hir_opt(cx
, arg
) {
981 let mut ty
= innermost
;
983 while let ty
::TyRef(_
, ty
::TypeAndMut { ty: inner, .. }
) = ty
.sty
{
987 let refs
: String
= iter
::repeat('
&'
).take(n
+ 1).collect();
988 let derefs
: String
= iter
::repeat('
*'
).take(n
).collect();
989 let explicit
= format
!("{}{}::clone({})", refs
, ty
, snip
);
990 db
.span_suggestion(expr
.span
, "try dereferencing it", format
!("{}({}{}).clone()", refs
, derefs
, snip
.deref()));
991 db
.span_suggestion(expr
.span
, "or try being explicit about what type to clone", explicit
);
994 return; // don't report clone_on_copy
1000 if let Some(snippet
) = sugg
::Sugg
::hir_opt(cx
, arg
) {
1001 if let ty
::TyRef(..) = cx
.tables
.expr_ty(arg
).sty
{
1002 let parent
= cx
.tcx
.hir
.get_parent_node(expr
.id
);
1003 match cx
.tcx
.hir
.get(parent
) {
1004 hir
::map
::NodeExpr(parent
) => match parent
.node
{
1005 // &*x is a nop, &x.clone() is not
1006 hir
::ExprAddrOf(..) |
1007 // (*x).func() is useless, x.clone().func() can work in case func borrows mutably
1008 hir
::ExprMethodCall(..) => return,
1011 hir
::map
::NodeStmt(stmt
) => {
1012 if let hir
::StmtDecl(ref decl
, _
) = stmt
.node
{
1013 if let hir
::DeclLocal(ref loc
) = decl
.node
{
1014 if let hir
::PatKind
::Ref(..) = loc
.pat
.node
{
1015 // let ref y = *x borrows x, let ref y = x.clone() does not
1023 snip
= Some(("try dereferencing it", format
!("{}", snippet
.deref())));
1025 snip
= Some(("try removing the `clone` call", format
!("{}", snippet
)));
1030 span_lint_and_then(cx
, CLONE_ON_COPY
, expr
.span
, "using `clone` on a `Copy` type", |db
| {
1031 if let Some((text
, snip
)) = snip
{
1032 db
.span_suggestion(expr
.span
, text
, snip
);
1038 fn lint_clone_on_ref_ptr(cx
: &LateContext
, expr
: &hir
::Expr
, arg
: &hir
::Expr
) {
1039 let (obj_ty
, _
) = walk_ptrs_ty_depth(cx
.tables
.expr_ty(arg
));
1041 if let ty
::TyAdt(_
, subst
) = obj_ty
.sty
{
1042 let caller_type
= if match_type(cx
, obj_ty
, &paths
::RC
) {
1044 } else if match_type(cx
, obj_ty
, &paths
::ARC
) {
1046 } else if match_type(cx
, obj_ty
, &paths
::WEAK_RC
) || match_type(cx
, obj_ty
, &paths
::WEAK_ARC
) {
1056 "using '.clone()' on a ref-counted pointer",
1058 format
!("{}::<{}>::clone(&{})", caller_type
, subst
.type_at(0), snippet(cx
, arg
.span
, "_")),
1064 fn lint_string_extend(cx
: &LateContext
, expr
: &hir
::Expr
, args
: &[hir
::Expr
]) {
1066 if let Some(arglists
) = method_chain_args(arg
, &["chars"]) {
1067 let target
= &arglists
[0][0];
1068 let (self_ty
, _
) = walk_ptrs_ty_depth(cx
.tables
.expr_ty(target
));
1069 let ref_str
= if self_ty
.sty
== ty
::TyStr
{
1071 } else if match_type(cx
, self_ty
, &paths
::STRING
) {
1079 STRING_EXTEND_CHARS
,
1081 "calling `.extend(_.chars())`",
1084 "{}.push_str({}{})",
1085 snippet(cx
, args
[0].span
, "_"),
1087 snippet(cx
, target
.span
, "_")
1093 fn lint_extend(cx
: &LateContext
, expr
: &hir
::Expr
, args
: &[hir
::Expr
]) {
1094 let (obj_ty
, _
) = walk_ptrs_ty_depth(cx
.tables
.expr_ty(&args
[0]));
1095 if match_type(cx
, obj_ty
, &paths
::STRING
) {
1096 lint_string_extend(cx
, expr
, args
);
1100 fn lint_cstring_as_ptr(cx
: &LateContext
, expr
: &hir
::Expr
, new
: &hir
::Expr
, unwrap
: &hir
::Expr
) {
1102 if let hir
::ExprCall(ref fun
, ref args
) = new
.node
;
1104 if let hir
::ExprPath(ref path
) = fun
.node
;
1105 if let Def
::Method(did
) = cx
.tables
.qpath_def(path
, fun
.hir_id
);
1106 if match_def_path(cx
.tcx
, did
, &paths
::CSTRING_NEW
);
1110 TEMPORARY_CSTRING_AS_PTR
,
1112 "you are getting the inner pointer of a temporary `CString`",
1114 db
.note("that pointer will be invalid outside this expression");
1115 db
.span_help(unwrap
.span
, "assign the `CString` to a variable to extend its lifetime");
1121 fn lint_iter_cloned_collect(cx
: &LateContext
, expr
: &hir
::Expr
, iter_args
: &[hir
::Expr
]) {
1122 if match_type(cx
, cx
.tables
.expr_ty(expr
), &paths
::VEC
)
1123 && derefs_to_slice(cx
, &iter_args
[0], cx
.tables
.expr_ty(&iter_args
[0])).is_some()
1127 ITER_CLONED_COLLECT
,
1129 "called `cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
1135 fn lint_unnecessary_fold(cx
: &LateContext
, expr
: &hir
::Expr
, fold_args
: &[hir
::Expr
]) {
1136 // Check that this is a call to Iterator::fold rather than just some function called fold
1137 if !match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1141 assert
!(fold_args
.len() == 3,
1142 "Expected fold_args to have three entries - the receiver, the initial value and the closure");
1144 fn check_fold_with_op(
1146 fold_args
: &[hir
::Expr
],
1148 replacement_method_name
: &str,
1149 replacement_has_args
: bool
) {
1152 // Extract the body of the closure passed to fold
1153 if let hir
::ExprClosure(_
, _
, body_id
, _
, _
) = fold_args
[2].node
;
1154 let closure_body
= cx
.tcx
.hir
.body(body_id
);
1155 let closure_expr
= remove_blocks(&closure_body
.value
);
1157 // Check if the closure body is of the form `acc <op> some_expr(x)`
1158 if let hir
::ExprBinary(ref bin_op
, ref left_expr
, ref right_expr
) = closure_expr
.node
;
1159 if bin_op
.node
== op
;
1161 // Extract the names of the two arguments to the closure
1162 if let Some(first_arg_ident
) = get_arg_name(&closure_body
.arguments
[0].pat
);
1163 if let Some(second_arg_ident
) = get_arg_name(&closure_body
.arguments
[1].pat
);
1165 if match_var(&*left_expr
, first_arg_ident
);
1166 if replacement_has_args
|| match_var(&*right_expr
, second_arg_ident
);
1169 // Span containing `.fold(...)`
1170 let next_point
= cx
.sess().codemap().next_point(fold_args
[0].span
);
1171 let fold_span
= next_point
.with_hi(fold_args
[2].span
.hi() + BytePos(1));
1173 let sugg
= if replacement_has_args
{
1175 ".{replacement}(|{s}| {r})",
1176 replacement
= replacement_method_name
,
1177 s
= second_arg_ident
,
1178 r
= snippet(cx
, right_expr
.span
, "EXPR"),
1183 replacement
= replacement_method_name
,
1191 // TODO #2371 don't suggest e.g. .any(|x| f(x)) if we can suggest .any(f)
1192 "this `.fold` can be written more succinctly using another method",
1200 // Check if the first argument to .fold is a suitable literal
1201 match fold_args
[1].node
{
1202 hir
::ExprLit(ref lit
) => {
1204 ast
::LitKind
::Bool(false) => check_fold_with_op(
1205 cx
, fold_args
, hir
::BinOp_
::BiOr
, "any", true
1207 ast
::LitKind
::Bool(true) => check_fold_with_op(
1208 cx
, fold_args
, hir
::BinOp_
::BiAnd
, "all", true
1210 ast
::LitKind
::Int(0, _
) => check_fold_with_op(
1211 cx
, fold_args
, hir
::BinOp_
::BiAdd
, "sum", false
1213 ast
::LitKind
::Int(1, _
) => check_fold_with_op(
1214 cx
, fold_args
, hir
::BinOp_
::BiMul
, "product", false
1223 fn lint_iter_nth(cx
: &LateContext
, expr
: &hir
::Expr
, iter_args
: &[hir
::Expr
], is_mut
: bool
) {
1224 let mut_str
= if is_mut { "_mut" }
else { "" }
;
1225 let caller_type
= if derefs_to_slice(cx
, &iter_args
[0], cx
.tables
.expr_ty(&iter_args
[0])).is_some() {
1227 } else if match_type(cx
, cx
.tables
.expr_ty(&iter_args
[0]), &paths
::VEC
) {
1229 } else if match_type(cx
, cx
.tables
.expr_ty(&iter_args
[0]), &paths
::VEC_DEQUE
) {
1232 return; // caller is not a type that we want to lint
1240 "called `.iter{0}().nth()` on a {1}. Calling `.get{0}()` is both faster and more readable",
1247 fn lint_get_unwrap(cx
: &LateContext
, expr
: &hir
::Expr
, get_args
: &[hir
::Expr
], is_mut
: bool
) {
1248 // Note: we don't want to lint `get_mut().unwrap` for HashMap or BTreeMap,
1249 // because they do not implement `IndexMut`
1250 let expr_ty
= cx
.tables
.expr_ty(&get_args
[0]);
1251 let caller_type
= if derefs_to_slice(cx
, &get_args
[0], expr_ty
).is_some() {
1253 } else if match_type(cx
, expr_ty
, &paths
::VEC
) {
1255 } else if match_type(cx
, expr_ty
, &paths
::VEC_DEQUE
) {
1257 } else if !is_mut
&& match_type(cx
, expr_ty
, &paths
::HASHMAP
) {
1259 } else if !is_mut
&& match_type(cx
, expr_ty
, &paths
::BTREEMAP
) {
1262 return; // caller is not a type that we want to lint
1265 let mut_str
= if is_mut { "_mut" }
else { "" }
;
1266 let borrow_str
= if is_mut { "&mut " }
else { "&" }
;
1272 "called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
1280 snippet(cx
, get_args
[0].span
, "_"),
1281 snippet(cx
, get_args
[1].span
, "_")
1286 fn lint_iter_skip_next(cx
: &LateContext
, expr
: &hir
::Expr
) {
1287 // lint if caller of skip is an Iterator
1288 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1293 "called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)`",
1298 fn derefs_to_slice(cx
: &LateContext
, expr
: &hir
::Expr
, ty
: Ty
) -> Option
<sugg
::Sugg
<'
static>> {
1299 fn may_slice(cx
: &LateContext
, ty
: Ty
) -> bool
{
1301 ty
::TySlice(_
) => true,
1302 ty
::TyAdt(def
, _
) if def
.is_box() => may_slice(cx
, ty
.boxed_ty()),
1303 ty
::TyAdt(..) => match_type(cx
, ty
, &paths
::VEC
),
1304 ty
::TyArray(_
, size
) => const_to_u64(size
) < 32,
1305 ty
::TyRef(_
, ty
::TypeAndMut { ty: inner, .. }
) => may_slice(cx
, inner
),
1310 if let hir
::ExprMethodCall(ref path
, _
, ref args
) = expr
.node
{
1311 if path
.name
== "iter" && may_slice(cx
, cx
.tables
.expr_ty(&args
[0])) {
1312 sugg
::Sugg
::hir_opt(cx
, &args
[0]).map(|sugg
| sugg
.addr())
1318 ty
::TySlice(_
) => sugg
::Sugg
::hir_opt(cx
, expr
),
1319 ty
::TyAdt(def
, _
) if def
.is_box() && may_slice(cx
, ty
.boxed_ty()) => sugg
::Sugg
::hir_opt(cx
, expr
),
1320 ty
::TyRef(_
, ty
::TypeAndMut { ty: inner, .. }
) => if may_slice(cx
, inner
) {
1321 sugg
::Sugg
::hir_opt(cx
, expr
)
1330 /// lint use of `unwrap()` for `Option`s and `Result`s
1331 fn lint_unwrap(cx
: &LateContext
, expr
: &hir
::Expr
, unwrap_args
: &[hir
::Expr
]) {
1332 let (obj_ty
, _
) = walk_ptrs_ty_depth(cx
.tables
.expr_ty(&unwrap_args
[0]));
1334 let mess
= if match_type(cx
, obj_ty
, &paths
::OPTION
) {
1335 Some((OPTION_UNWRAP_USED
, "an Option", "None"))
1336 } else if match_type(cx
, obj_ty
, &paths
::RESULT
) {
1337 Some((RESULT_UNWRAP_USED
, "a Result", "Err"))
1342 if let Some((lint
, kind
, none_value
)) = mess
{
1348 "used unwrap() on {} value. If you don't want to handle the {} case gracefully, consider \
1349 using expect() to provide a better panic \
1358 /// lint use of `ok().expect()` for `Result`s
1359 fn lint_ok_expect(cx
: &LateContext
, expr
: &hir
::Expr
, ok_args
: &[hir
::Expr
]) {
1360 // lint if the caller of `ok()` is a `Result`
1361 if match_type(cx
, cx
.tables
.expr_ty(&ok_args
[0]), &paths
::RESULT
) {
1362 let result_type
= cx
.tables
.expr_ty(&ok_args
[0]);
1363 if let Some(error_type
) = get_error_type(cx
, result_type
) {
1364 if has_debug_impl(error_type
, cx
) {
1369 "called `ok().expect()` on a Result value. You can call `expect` directly on the `Result`",
1376 /// lint use of `map().unwrap_or()` for `Option`s
1377 fn lint_map_unwrap_or(cx
: &LateContext
, expr
: &hir
::Expr
, map_args
: &[hir
::Expr
], unwrap_args
: &[hir
::Expr
]) {
1378 // lint if the caller of `map()` is an `Option`
1379 if match_type(cx
, cx
.tables
.expr_ty(&map_args
[0]), &paths
::OPTION
) {
1380 // get snippets for args to map() and unwrap_or()
1381 let map_snippet
= snippet(cx
, map_args
[1].span
, "..");
1382 let unwrap_snippet
= snippet(cx
, unwrap_args
[1].span
, "..");
1384 // comparing the snippet from source to raw text ("None") below is safe
1385 // because we already have checked the type.
1386 let arg
= if unwrap_snippet
== "None" {
1391 let suggest
= if unwrap_snippet
== "None" {
1397 "called `map(f).unwrap_or({})` on an Option value. \
1398 This can be done more directly by calling `{}` instead",
1402 // lint, with note if neither arg is > 1 line and both map() and
1403 // unwrap_or() have the same span
1404 let multiline
= map_snippet
.lines().count() > 1 || unwrap_snippet
.lines().count() > 1;
1405 let same_span
= map_args
[1].span
.ctxt() == unwrap_args
[1].span
.ctxt();
1406 if same_span
&& !multiline
{
1407 let suggest
= if unwrap_snippet
== "None" {
1408 format
!("and_then({})", map_snippet
)
1410 format
!("map_or({}, {})", unwrap_snippet
, map_snippet
)
1413 "replace `map({}).unwrap_or({})` with `{}`",
1418 span_note_and_lint(cx
, OPTION_MAP_UNWRAP_OR
, expr
.span
, msg
, expr
.span
, ¬e
);
1419 } else if same_span
&& multiline
{
1420 span_lint(cx
, OPTION_MAP_UNWRAP_OR
, expr
.span
, msg
);
1425 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
1426 fn lint_map_unwrap_or_else
<'a
, 'tcx
>(
1427 cx
: &LateContext
<'a
, 'tcx
>,
1428 expr
: &'tcx hir
::Expr
,
1429 map_args
: &'tcx
[hir
::Expr
],
1430 unwrap_args
: &'tcx
[hir
::Expr
],
1432 // lint if the caller of `map()` is an `Option`
1433 let is_option
= match_type(cx
, cx
.tables
.expr_ty(&map_args
[0]), &paths
::OPTION
);
1434 let is_result
= match_type(cx
, cx
.tables
.expr_ty(&map_args
[0]), &paths
::RESULT
);
1435 if is_option
|| is_result
{
1437 let msg
= if is_option
{
1438 "called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling \
1439 `map_or_else(g, f)` instead"
1441 "called `map(f).unwrap_or_else(g)` on a Result value. This can be done more directly by calling \
1442 `ok().map_or_else(g, f)` instead"
1444 // get snippets for args to map() and unwrap_or_else()
1445 let map_snippet
= snippet(cx
, map_args
[1].span
, "..");
1446 let unwrap_snippet
= snippet(cx
, unwrap_args
[1].span
, "..");
1447 // lint, with note if neither arg is > 1 line and both map() and
1448 // unwrap_or_else() have the same span
1449 let multiline
= map_snippet
.lines().count() > 1 || unwrap_snippet
.lines().count() > 1;
1450 let same_span
= map_args
[1].span
.ctxt() == unwrap_args
[1].span
.ctxt();
1451 if same_span
&& !multiline
{
1455 OPTION_MAP_UNWRAP_OR_ELSE
1457 RESULT_MAP_UNWRAP_OR_ELSE
1463 "replace `map({0}).unwrap_or_else({1})` with `{2}map_or_else({1}, {0})`",
1466 if is_result { "ok()." }
else { "" }
1469 } else if same_span
&& multiline
{
1473 OPTION_MAP_UNWRAP_OR_ELSE
1475 RESULT_MAP_UNWRAP_OR_ELSE
1484 /// lint use of `_.map_or(None, _)` for `Option`s
1485 fn lint_map_or_none
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, expr
: &'tcx hir
::Expr
, map_or_args
: &'tcx
[hir
::Expr
]) {
1486 if match_type(cx
, cx
.tables
.expr_ty(&map_or_args
[0]), &paths
::OPTION
) {
1487 // check if the first non-self argument to map_or() is None
1488 let map_or_arg_is_none
= if let hir
::Expr_
::ExprPath(ref qpath
) = map_or_args
[1].node
{
1489 match_qpath(qpath
, &paths
::OPTION_NONE
)
1494 if map_or_arg_is_none
{
1496 let msg
= "called `map_or(None, f)` on an Option value. This can be done more directly by calling \
1497 `and_then(f)` instead";
1498 let map_or_self_snippet
= snippet(cx
, map_or_args
[0].span
, "..");
1499 let map_or_func_snippet
= snippet(cx
, map_or_args
[2].span
, "..");
1500 let hint
= format
!("{0}.and_then({1})", map_or_self_snippet
, map_or_func_snippet
);
1501 span_lint_and_then(cx
, OPTION_MAP_OR_NONE
, expr
.span
, msg
, |db
| {
1502 db
.span_suggestion(expr
.span
, "try using and_then instead", hint
);
1508 /// lint use of `filter().next()` for `Iterators`
1509 fn lint_filter_next
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, expr
: &'tcx hir
::Expr
, filter_args
: &'tcx
[hir
::Expr
]) {
1510 // lint if caller of `.filter().next()` is an Iterator
1511 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1512 let msg
= "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
1513 `.find(p)` instead.";
1514 let filter_snippet
= snippet(cx
, filter_args
[1].span
, "..");
1515 if filter_snippet
.lines().count() <= 1 {
1516 // add note if not multi-line
1523 &format
!("replace `filter({0}).next()` with `find({0})`", filter_snippet
),
1526 span_lint(cx
, FILTER_NEXT
, expr
.span
, msg
);
1531 /// lint use of `filter().map()` for `Iterators`
1532 fn lint_filter_map
<'a
, 'tcx
>(
1533 cx
: &LateContext
<'a
, 'tcx
>,
1534 expr
: &'tcx hir
::Expr
,
1535 _filter_args
: &'tcx
[hir
::Expr
],
1536 _map_args
: &'tcx
[hir
::Expr
],
1538 // lint if caller of `.filter().map()` is an Iterator
1539 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1540 let msg
= "called `filter(p).map(q)` on an `Iterator`. \
1541 This is more succinctly expressed by calling `.filter_map(..)` instead.";
1542 span_lint(cx
, FILTER_MAP
, expr
.span
, msg
);
1546 /// lint use of `filter().map()` for `Iterators`
1547 fn lint_filter_map_map
<'a
, 'tcx
>(
1548 cx
: &LateContext
<'a
, 'tcx
>,
1549 expr
: &'tcx hir
::Expr
,
1550 _filter_args
: &'tcx
[hir
::Expr
],
1551 _map_args
: &'tcx
[hir
::Expr
],
1553 // lint if caller of `.filter().map()` is an Iterator
1554 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1555 let msg
= "called `filter_map(p).map(q)` on an `Iterator`. \
1556 This is more succinctly expressed by only calling `.filter_map(..)` instead.";
1557 span_lint(cx
, FILTER_MAP
, expr
.span
, msg
);
1561 /// lint use of `filter().flat_map()` for `Iterators`
1562 fn lint_filter_flat_map
<'a
, 'tcx
>(
1563 cx
: &LateContext
<'a
, 'tcx
>,
1564 expr
: &'tcx hir
::Expr
,
1565 _filter_args
: &'tcx
[hir
::Expr
],
1566 _map_args
: &'tcx
[hir
::Expr
],
1568 // lint if caller of `.filter().flat_map()` is an Iterator
1569 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1570 let msg
= "called `filter(p).flat_map(q)` on an `Iterator`. \
1571 This is more succinctly expressed by calling `.flat_map(..)` \
1572 and filtering by returning an empty Iterator.";
1573 span_lint(cx
, FILTER_MAP
, expr
.span
, msg
);
1577 /// lint use of `filter_map().flat_map()` for `Iterators`
1578 fn lint_filter_map_flat_map
<'a
, 'tcx
>(
1579 cx
: &LateContext
<'a
, 'tcx
>,
1580 expr
: &'tcx hir
::Expr
,
1581 _filter_args
: &'tcx
[hir
::Expr
],
1582 _map_args
: &'tcx
[hir
::Expr
],
1584 // lint if caller of `.filter_map().flat_map()` is an Iterator
1585 if match_trait_method(cx
, expr
, &paths
::ITERATOR
) {
1586 let msg
= "called `filter_map(p).flat_map(q)` on an `Iterator`. \
1587 This is more succinctly expressed by calling `.flat_map(..)` \
1588 and filtering by returning an empty Iterator.";
1589 span_lint(cx
, FILTER_MAP
, expr
.span
, msg
);
1593 /// lint searching an Iterator followed by `is_some()`
1594 fn lint_search_is_some
<'a
, 'tcx
>(
1595 cx
: &LateContext
<'a
, 'tcx
>,
1596 expr
: &'tcx hir
::Expr
,
1597 search_method
: &str,
1598 search_args
: &'tcx
[hir
::Expr
],
1599 is_some_args
: &'tcx
[hir
::Expr
],
1601 // lint if caller of search is an Iterator
1602 if match_trait_method(cx
, &is_some_args
[0], &paths
::ITERATOR
) {
1604 "called `is_some()` after searching an `Iterator` with {}. This is more succinctly \
1605 expressed by calling `any()`.",
1608 let search_snippet
= snippet(cx
, search_args
[1].span
, "..");
1609 if search_snippet
.lines().count() <= 1 {
1610 // add note if not multi-line
1617 &format
!("replace `{0}({1}).is_some()` with `any({1})`", search_method
, search_snippet
),
1620 span_lint(cx
, SEARCH_IS_SOME
, expr
.span
, &msg
);
1625 /// Used for `lint_binary_expr_with_method_call`.
1626 #[derive(Copy, Clone)]
1627 struct BinaryExprInfo
<'a
> {
1628 expr
: &'a hir
::Expr
,
1629 chain
: &'a hir
::Expr
,
1630 other
: &'a hir
::Expr
,
1634 /// Checks for the `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
1635 fn lint_binary_expr_with_method_call
<'a
, 'tcx
: 'a
>(cx
: &LateContext
<'a
, 'tcx
>, info
: &mut BinaryExprInfo
) {
1636 macro_rules
! lint_with_both_lhs_and_rhs
{
1637 ($func
:ident
, $cx
:expr
, $info
:ident
) => {
1638 if !$
func($cx
, $info
) {
1639 ::std
::mem
::swap(&mut $info
.chain
, &mut $info
.other
);
1640 if $
func($cx
, $info
) {
1647 lint_with_both_lhs_and_rhs
!(lint_chars_next_cmp
, cx
, info
);
1648 lint_with_both_lhs_and_rhs
!(lint_chars_last_cmp
, cx
, info
);
1649 lint_with_both_lhs_and_rhs
!(lint_chars_next_cmp_with_unwrap
, cx
, info
);
1650 lint_with_both_lhs_and_rhs
!(lint_chars_last_cmp_with_unwrap
, cx
, info
);
1653 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_NEXT_CMP` lints.
1654 fn lint_chars_cmp
<'a
, 'tcx
>(
1655 cx
: &LateContext
<'a
, 'tcx
>,
1656 info
: &BinaryExprInfo
,
1657 chain_methods
: &[&str],
1658 lint
: &'
static Lint
,
1662 if let Some(args
) = method_chain_args(info
.chain
, chain_methods
);
1663 if let hir
::ExprCall(ref fun
, ref arg_char
) = info
.other
.node
;
1664 if arg_char
.len() == 1;
1665 if let hir
::ExprPath(ref qpath
) = fun
.node
;
1666 if let Some(segment
) = single_segment_path(qpath
);
1667 if segment
.name
== "Some";
1669 let self_ty
= walk_ptrs_ty(cx
.tables
.expr_ty_adjusted(&args
[0][0]));
1671 if self_ty
.sty
!= ty
::TyStr
{
1675 span_lint_and_sugg(cx
,
1678 &format
!("you should use the `{}` method", suggest
),
1680 format
!("{}{}.{}({})",
1681 if info
.eq { "" }
else { "!" }
,
1682 snippet(cx
, args
[0][0].span
, "_"),
1684 snippet(cx
, arg_char
[0].span
, "_")));
1693 /// Checks for the `CHARS_NEXT_CMP` lint.
1694 fn lint_chars_next_cmp
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, info
: &BinaryExprInfo
) -> bool
{
1695 lint_chars_cmp(cx
, info
, &["chars", "next"], CHARS_NEXT_CMP
, "starts_with")
1698 /// Checks for the `CHARS_LAST_CMP` lint.
1699 fn lint_chars_last_cmp
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, info
: &BinaryExprInfo
) -> bool
{
1700 if lint_chars_cmp(cx
, info
, &["chars", "last"], CHARS_NEXT_CMP
, "ends_with") {
1703 lint_chars_cmp(cx
, info
, &["chars", "next_back"], CHARS_NEXT_CMP
, "ends_with")
1707 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
1708 fn lint_chars_cmp_with_unwrap
<'a
, 'tcx
>(
1709 cx
: &LateContext
<'a
, 'tcx
>,
1710 info
: &BinaryExprInfo
,
1711 chain_methods
: &[&str],
1712 lint
: &'
static Lint
,
1716 if let Some(args
) = method_chain_args(info
.chain
, chain_methods
);
1717 if let hir
::ExprLit(ref lit
) = info
.other
.node
;
1718 if let ast
::LitKind
::Char(c
) = lit
.node
;
1724 &format
!("you should use the `{}` method", suggest
),
1726 format
!("{}{}.{}('{}')",
1727 if info
.eq { "" }
else { "!" }
,
1728 snippet(cx
, args
[0][0].span
, "_"),
1740 /// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
1741 fn lint_chars_next_cmp_with_unwrap
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, info
: &BinaryExprInfo
) -> bool
{
1742 lint_chars_cmp_with_unwrap(cx
, info
, &["chars", "next", "unwrap"], CHARS_NEXT_CMP
, "starts_with")
1745 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
1746 fn lint_chars_last_cmp_with_unwrap
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, info
: &BinaryExprInfo
) -> bool
{
1747 if lint_chars_cmp_with_unwrap(cx
, info
, &["chars", "last", "unwrap"], CHARS_LAST_CMP
, "ends_with") {
1750 lint_chars_cmp_with_unwrap(cx
, info
, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP
, "ends_with")
1754 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
1755 fn lint_single_char_pattern
<'a
, 'tcx
>(cx
: &LateContext
<'a
, 'tcx
>, expr
: &'tcx hir
::Expr
, arg
: &'tcx hir
::Expr
) {
1756 let parent_item
= cx
.tcx
.hir
.get_parent(arg
.id
);
1757 let parent_def_id
= cx
.tcx
.hir
.local_def_id(parent_item
);
1758 let substs
= Substs
::identity_for_item(cx
.tcx
, parent_def_id
);
1759 if let Ok(&ty
::Const
{
1760 val
: ConstVal
::Str(r
),
1762 }) = ConstContext
::new(cx
.tcx
, cx
.param_env
.and(substs
), cx
.tables
).eval(arg
)
1765 let hint
= snippet(cx
, expr
.span
, "..").replace(&format
!("\"{}\"", r
), &format
!("'{}'", r
));
1768 SINGLE_CHAR_PATTERN
,
1770 "single-character string constant used as pattern",
1772 db
.span_suggestion(expr
.span
, "try using a char instead", hint
);
1779 /// Checks for the `USELESS_ASREF` lint.
1780 fn lint_asref(cx
: &LateContext
, expr
: &hir
::Expr
, call_name
: &str, as_ref_args
: &[hir
::Expr
]) {
1781 // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
1782 // check if the call is to the actual `AsRef` or `AsMut` trait
1783 if match_trait_method(cx
, expr
, &paths
::ASREF_TRAIT
) || match_trait_method(cx
, expr
, &paths
::ASMUT_TRAIT
) {
1784 // check if the type after `as_ref` or `as_mut` is the same as before
1785 let recvr
= &as_ref_args
[0];
1786 let rcv_ty
= cx
.tables
.expr_ty(recvr
);
1787 let res_ty
= cx
.tables
.expr_ty(expr
);
1788 let (base_res_ty
, res_depth
) = walk_ptrs_ty_depth(res_ty
);
1789 let (base_rcv_ty
, rcv_depth
) = walk_ptrs_ty_depth(rcv_ty
);
1790 if base_rcv_ty
== base_res_ty
&& rcv_depth
>= res_depth
{
1795 &format
!("this call to `{}` does nothing", call_name
),
1797 snippet(cx
, recvr
.span
, "_").into_owned(),
1803 /// Given a `Result<T, E>` type, return its error type (`E`).
1804 fn get_error_type
<'a
>(cx
: &LateContext
, ty
: Ty
<'a
>) -> Option
<Ty
<'a
>> {
1805 if let ty
::TyAdt(_
, substs
) = ty
.sty
{
1806 if match_type(cx
, ty
, &paths
::RESULT
) {
1807 substs
.types().nth(1)
1816 /// This checks whether a given type is known to implement Debug.
1817 fn has_debug_impl
<'a
, 'b
>(ty
: Ty
<'a
>, cx
: &LateContext
<'b
, 'a
>) -> bool
{
1818 match cx
.tcx
.lang_items().debug_trait() {
1819 Some(debug
) => implements_trait(cx
, ty
, debug
, &[]),
1826 StartsWith(&'
static str),
1829 #[cfg_attr(rustfmt, rustfmt_skip)]
1830 const CONVENTIONS
: [(Convention
, &[SelfKind
]); 6] = [
1831 (Convention
::Eq("new"), &[SelfKind
::No
]),
1832 (Convention
::StartsWith("as_"), &[SelfKind
::Ref
, SelfKind
::RefMut
]),
1833 (Convention
::StartsWith("from_"), &[SelfKind
::No
]),
1834 (Convention
::StartsWith("into_"), &[SelfKind
::Value
]),
1835 (Convention
::StartsWith("is_"), &[SelfKind
::Ref
, SelfKind
::No
]),
1836 (Convention
::StartsWith("to_"), &[SelfKind
::Ref
]),
1839 #[cfg_attr(rustfmt, rustfmt_skip)]
1840 const TRAIT_METHODS
: [(&str, usize, SelfKind
, OutType
, &str); 30] = [
1841 ("add", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Add"),
1842 ("as_mut", 1, SelfKind
::RefMut
, OutType
::Ref
, "std::convert::AsMut"),
1843 ("as_ref", 1, SelfKind
::Ref
, OutType
::Ref
, "std::convert::AsRef"),
1844 ("bitand", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::BitAnd"),
1845 ("bitor", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::BitOr"),
1846 ("bitxor", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::BitXor"),
1847 ("borrow", 1, SelfKind
::Ref
, OutType
::Ref
, "std::borrow::Borrow"),
1848 ("borrow_mut", 1, SelfKind
::RefMut
, OutType
::Ref
, "std::borrow::BorrowMut"),
1849 ("clone", 1, SelfKind
::Ref
, OutType
::Any
, "std::clone::Clone"),
1850 ("cmp", 2, SelfKind
::Ref
, OutType
::Any
, "std::cmp::Ord"),
1851 ("default", 0, SelfKind
::No
, OutType
::Any
, "std::default::Default"),
1852 ("deref", 1, SelfKind
::Ref
, OutType
::Ref
, "std::ops::Deref"),
1853 ("deref_mut", 1, SelfKind
::RefMut
, OutType
::Ref
, "std::ops::DerefMut"),
1854 ("div", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Div"),
1855 ("drop", 1, SelfKind
::RefMut
, OutType
::Unit
, "std::ops::Drop"),
1856 ("eq", 2, SelfKind
::Ref
, OutType
::Bool
, "std::cmp::PartialEq"),
1857 ("from_iter", 1, SelfKind
::No
, OutType
::Any
, "std::iter::FromIterator"),
1858 ("from_str", 1, SelfKind
::No
, OutType
::Any
, "std::str::FromStr"),
1859 ("hash", 2, SelfKind
::Ref
, OutType
::Unit
, "std::hash::Hash"),
1860 ("index", 2, SelfKind
::Ref
, OutType
::Ref
, "std::ops::Index"),
1861 ("index_mut", 2, SelfKind
::RefMut
, OutType
::Ref
, "std::ops::IndexMut"),
1862 ("into_iter", 1, SelfKind
::Value
, OutType
::Any
, "std::iter::IntoIterator"),
1863 ("mul", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Mul"),
1864 ("neg", 1, SelfKind
::Value
, OutType
::Any
, "std::ops::Neg"),
1865 ("next", 1, SelfKind
::RefMut
, OutType
::Any
, "std::iter::Iterator"),
1866 ("not", 1, SelfKind
::Value
, OutType
::Any
, "std::ops::Not"),
1867 ("rem", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Rem"),
1868 ("shl", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Shl"),
1869 ("shr", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Shr"),
1870 ("sub", 2, SelfKind
::Value
, OutType
::Any
, "std::ops::Sub"),
1873 #[cfg_attr(rustfmt, rustfmt_skip)]
1874 const PATTERN_METHODS
: [(&str, usize); 17] = [
1882 ("split_terminator", 1),
1883 ("rsplit_terminator", 1),
1888 ("match_indices", 1),
1889 ("rmatch_indices", 1),
1890 ("trim_left_matches", 1),
1891 ("trim_right_matches", 1),
1895 #[derive(Clone, Copy, PartialEq, Debug)]
1909 allow_value_for_ref
: bool
,
1910 generics
: &hir
::Generics
,
1912 // Self types in the HIR are desugared to explicit self types. So it will
1915 // where SomeType can be `Self` or an explicit impl self type (e.g. `Foo` if
1916 // the impl is on `Foo`)
1917 // Thus, we only need to test equality against the impl self type or if it is
1919 // `Self`. Furthermore, the only possible types for `self: ` are `&Self`,
1920 // `Self`, `&mut Self`,
1921 // and `Box<Self>`, including the equivalent types with `Foo`.
1923 let is_actually_self
= |ty
| is_self_ty(ty
) || ty
== self_ty
;
1926 SelfKind
::Value
=> is_actually_self(ty
),
1927 SelfKind
::Ref
| SelfKind
::RefMut
=> {
1928 if allow_value_for_ref
&& is_actually_self(ty
) {
1932 hir
::TyRptr(_
, ref mt_ty
) => {
1933 let mutability_match
= if self == SelfKind
::Ref
{
1934 mt_ty
.mutbl
== hir
::MutImmutable
1936 mt_ty
.mutbl
== hir
::MutMutable
1938 is_actually_self(&mt_ty
.ty
) && mutability_match
1947 SelfKind
::Value
=> false,
1948 SelfKind
::Ref
=> is_as_ref_or_mut_trait(ty
, self_ty
, generics
, &paths
::ASREF_TRAIT
),
1949 SelfKind
::RefMut
=> is_as_ref_or_mut_trait(ty
, self_ty
, generics
, &paths
::ASMUT_TRAIT
),
1950 SelfKind
::No
=> true,
1955 fn description(&self) -> &'
static str {
1957 SelfKind
::Value
=> "self by value",
1958 SelfKind
::Ref
=> "self by reference",
1959 SelfKind
::RefMut
=> "self by mutable reference",
1960 SelfKind
::No
=> "no self",
1965 fn is_as_ref_or_mut_trait(ty
: &hir
::Ty
, self_ty
: &hir
::Ty
, generics
: &hir
::Generics
, name
: &[&str]) -> bool
{
1966 single_segment_ty(ty
).map_or(false, |seg
| {
1967 generics
.ty_params().any(|param
| {
1968 param
.name
== seg
.name
&& param
.bounds
.iter().any(|bound
| {
1969 if let hir
::TyParamBound
::TraitTyParamBound(ref ptr
, ..) = *bound
{
1970 let path
= &ptr
.trait_ref
.path
;
1971 match_path(path
, name
) && path
.segments
.last().map_or(false, |s
| {
1972 if let Some(ref params
) = s
.parameters
{
1973 if params
.parenthesized
{
1976 params
.types
.len() == 1
1977 && (is_self_ty(¶ms
.types
[0]) || is_ty(&*params
.types
[0], self_ty
))
1991 fn is_ty(ty
: &hir
::Ty
, self_ty
: &hir
::Ty
) -> bool
{
1992 match (&ty
.node
, &self_ty
.node
) {
1994 &hir
::TyPath(hir
::QPath
::Resolved(_
, ref ty_path
)),
1995 &hir
::TyPath(hir
::QPath
::Resolved(_
, ref self_ty_path
)),
1999 .map(|seg
| seg
.name
)
2000 .eq(self_ty_path
.segments
.iter().map(|seg
| seg
.name
)),
2005 fn single_segment_ty(ty
: &hir
::Ty
) -> Option
<&hir
::PathSegment
> {
2006 if let hir
::TyPath(ref path
) = ty
.node
{
2007 single_segment_path(path
)
2014 fn check(&self, other
: &str) -> bool
{
2016 Convention
::Eq(this
) => this
== other
,
2017 Convention
::StartsWith(this
) => other
.starts_with(this
) && this
!= other
,
2022 impl fmt
::Display
for Convention
{
2023 fn fmt(&self, f
: &mut fmt
::Formatter
) -> Result
<(), fmt
::Error
> {
2025 Convention
::Eq(this
) => this
.fmt(f
),
2026 Convention
::StartsWith(this
) => this
.fmt(f
).and_then(|_
| '
*'
.fmt(f
)),
2031 #[derive(Clone, Copy)]
2040 fn matches(&self, ty
: &hir
::FunctionRetTy
) -> bool
{
2042 (&OutType
::Unit
, &hir
::DefaultReturn(_
)) => true,
2043 (&OutType
::Unit
, &hir
::Return(ref ty
)) if ty
.node
== hir
::TyTup(vec
![].into()) => true,
2044 (&OutType
::Bool
, &hir
::Return(ref ty
)) if is_bool(ty
) => true,
2045 (&OutType
::Any
, &hir
::Return(ref ty
)) if ty
.node
!= hir
::TyTup(vec
![].into()) => true,
2046 (&OutType
::Ref
, &hir
::Return(ref ty
)) => matches
!(ty
.node
, hir
::TyRptr(_
, _
)),
2052 fn is_bool(ty
: &hir
::Ty
) -> bool
{
2053 if let hir
::TyPath(ref p
) = ty
.node
{
2054 match_qpath(p
, &["bool"])