+mod bind_instead_of_map;
mod inefficient_to_string;
mod manual_saturating_arithmetic;
mod option_map_unwrap_or;
use std::fmt;
use std::iter;
+use bind_instead_of_map::BindInsteadOfMap;
use if_chain::if_chain;
-use rustc::hir::map::Map;
-use rustc::lint::in_external_macro;
-use rustc::ty::{self, Predicate, Ty};
use rustc_ast::ast;
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_hir::intravisit::{self, Visitor};
use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, Ty, TyS};
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Symbol, SymbolStr};
+use rustc_span::symbol::{sym, SymbolStr};
use crate::consts::{constant, Constant};
use crate::utils::usage::mutated_variables;
use crate::utils::{
- get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro, is_copy,
+ get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro, is_copy,
is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls, method_chain_args, paths,
- remove_blocks, return_ty, same_tys, single_segment_path, snippet, snippet_with_applicability,
- snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
- span_lint_and_then, sugg, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
+ remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+ span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty,
+ walk_ptrs_ty_depth, SpanlessEq,
};
declare_clippy_lint! {
- /// **What it does:** Checks for `.unwrap()` calls on `Option`s.
+ /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
///
- /// **Why is this bad?** Usually it is better to handle the `None` case, or to
- /// at least call `.expect(_)` with a more helpful message. Still, for a lot of
+ /// **Why is this bad?** It is better to handle the `None` or `Err` case,
+ /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
/// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
/// `Allow` by default.
///
- /// **Known problems:** None.
- ///
- /// **Example:**
- ///
- /// Using unwrap on an `Option`:
- ///
- /// ```rust
- /// let opt = Some(1);
- /// opt.unwrap();
- /// ```
- ///
- /// Better:
- ///
- /// ```rust
- /// let opt = Some(1);
- /// opt.expect("more helpful message");
- /// ```
- pub OPTION_UNWRAP_USED,
- restriction,
- "using `Option.unwrap()`, which should at least get a better message using `expect()`"
-}
-
-declare_clippy_lint! {
- /// **What it does:** Checks for `.unwrap()` calls on `Result`s.
- ///
- /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err`
- /// values. Normally, you want to implement more sophisticated error handling,
+ /// `result.unwrap()` will let the thread panic on `Err` values.
+ /// Normally, you want to implement more sophisticated error handling,
/// and propagate errors upwards with `?` operator.
///
/// Even if you want to panic on errors, not all `Error`s implement good
///
/// **Known problems:** None.
///
- /// **Example:**
- /// Using unwrap on an `Result`:
- ///
+ /// **Examples:**
/// ```rust
- /// let res: Result<usize, ()> = Ok(1);
- /// res.unwrap();
+ /// # let opt = Some(1);
+ ///
+ /// // Bad
+ /// opt.unwrap();
+ ///
+ /// // Good
+ /// opt.expect("more helpful message");
/// ```
///
- /// Better:
+ /// // or
///
/// ```rust
- /// let res: Result<usize, ()> = Ok(1);
+ /// # let res: Result<usize, ()> = Ok(1);
+ ///
+ /// // Bad
+ /// res.unwrap();
+ ///
+ /// // Good
/// res.expect("more helpful message");
/// ```
- pub RESULT_UNWRAP_USED,
+ pub UNWRAP_USED,
restriction,
- "using `Result.unwrap()`, which might be better handled"
+ "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for `.expect()` calls on `Option`s.
+ /// **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.
///
- /// **Why is this bad?** Usually it is better to handle the `None` case. Still,
- /// for a lot of quick-and-dirty code, `expect` is a good choice, which is why
- /// this lint is `Allow` by default.
+ /// **Why is this bad?** Usually it is better to handle the `None` or `Err` case.
+ /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
+ /// this lint is `Allow` by default.
///
- /// **Known problems:** None.
+ /// `result.expect()` will let the thread panic on `Err`
+ /// values. Normally, you want to implement more sophisticated error handling,
+ /// and propagate errors upwards with `?` operator.
///
- /// **Example:**
+ /// **Known problems:** None.
///
- /// Using expect on an `Option`:
+ /// **Examples:**
+ /// ```rust,ignore
+ /// # let opt = Some(1);
///
- /// ```rust
- /// let opt = Some(1);
+ /// // Bad
/// opt.expect("one");
- /// ```
- ///
- /// Better:
///
- /// ```rust,ignore
+ /// // Good
/// let opt = Some(1);
/// opt?;
/// ```
- pub OPTION_EXPECT_USED,
- restriction,
- "using `Option.expect()`, which might be better handled"
-}
-
-declare_clippy_lint! {
- /// **What it does:** Checks for `.expect()` calls on `Result`s.
///
- /// **Why is this bad?** `result.expect()` will let the thread panic on `Err`
- /// values. Normally, you want to implement more sophisticated error handling,
- /// and propagate errors upwards with `?` operator.
- ///
- /// **Known problems:** None.
- ///
- /// **Example:**
- /// Using expect on an `Result`:
+ /// // or
///
/// ```rust
- /// let res: Result<usize, ()> = Ok(1);
- /// res.expect("one");
- /// ```
+ /// # let res: Result<usize, ()> = Ok(1);
///
- /// Better:
+ /// // Bad
+ /// res.expect("one");
///
- /// ```rust
- /// let res: Result<usize, ()> = Ok(1);
+ /// // Good
/// res?;
/// # Ok::<(), ()>(())
/// ```
- pub RESULT_EXPECT_USED,
+ pub EXPECT_USED,
restriction,
- "using `Result.expect()`, which might be better handled"
+ "using `.expect()` on `Result` or `Option`, which might be better handled"
}
declare_clippy_lint! {
/// **Example:**
/// ```rust
/// # let x = Ok::<_, ()>(());
- /// x.ok().expect("why did I do this again?")
+ ///
+ /// // Bad
+ /// x.ok().expect("why did I do this again?");
+ ///
+ /// // Good
+ /// x.expect("why did I do this again?");
/// ```
pub OK_EXPECT,
style,
}
declare_clippy_lint! {
- /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`.
+ /// **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+ /// `result.map(_).unwrap_or_else(_)`.
///
- /// **Why is this bad?** Readability, this can be written more concisely as
- /// `_.map_or(_, _)`.
+ /// **Why is this bad?** Readability, these can be written more concisely (resp.) as
+ /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
///
/// **Known problems:** The order of the arguments is not in execution order
///
- /// **Example:**
+ /// **Examples:**
/// ```rust
/// # let x = Some(1);
+ ///
+ /// // Bad
/// x.map(|a| a + 1).unwrap_or(0);
- /// ```
- pub OPTION_MAP_UNWRAP_OR,
- pedantic,
- "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`"
-}
-
-declare_clippy_lint! {
- /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`.
///
- /// **Why is this bad?** Readability, this can be written more concisely as
- /// `_.map_or_else(_, _)`.
+ /// // Good
+ /// x.map_or(0, |a| a + 1);
+ /// ```
///
- /// **Known problems:** The order of the arguments is not in execution order.
+ /// // or
///
- /// **Example:**
/// ```rust
- /// # let x = Some(1);
- /// # fn some_function() -> usize { 1 }
+ /// # let x: Result<usize, ()> = Ok(1);
+ /// # fn some_function(foo: ()) -> usize { 1 }
+ ///
+ /// // Bad
/// x.map(|a| a + 1).unwrap_or_else(some_function);
+ ///
+ /// // Good
+ /// x.map_or_else(some_function, |a| a + 1);
/// ```
- pub OPTION_MAP_UNWRAP_OR_ELSE,
+ pub MAP_UNWRAP_OR,
pedantic,
- "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`"
+ "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`.
+ /// **What it does:** Checks for usage of `_.map_or(None, _)`.
///
/// **Why is this bad?** Readability, this can be written more concisely as
- /// `result.map_or_else(_, _)`.
+ /// `_.and_then(_)`.
///
- /// **Known problems:** None.
+ /// **Known problems:** The order of the arguments is not in execution order.
///
/// **Example:**
/// ```rust
- /// # let x: Result<usize, ()> = Ok(1);
- /// # fn some_function(foo: ()) -> usize { 1 }
- /// x.map(|a| a + 1).unwrap_or_else(some_function);
+ /// # let opt = Some(1);
+ ///
+ /// // Bad
+ /// opt.map_or(None, |a| Some(a + 1));
+ ///
+ /// // Good
+ /// opt.and_then(|a| Some(a + 1));
/// ```
- pub RESULT_MAP_UNWRAP_OR_ELSE,
- pedantic,
- "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.map_or_else(g, f)`"
+ pub OPTION_MAP_OR_NONE,
+ style,
+ "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for usage of `_.map_or(None, _)`.
+ /// **What it does:** Checks for usage of `_.map_or(None, Some)`.
///
/// **Why is this bad?** Readability, this can be written more concisely as
- /// `_.and_then(_)`.
+ /// `_.ok()`.
///
- /// **Known problems:** The order of the arguments is not in execution order.
+ /// **Known problems:** None.
///
/// **Example:**
+ ///
+ /// Bad:
/// ```rust
- /// # let opt = Some(1);
- /// opt.map_or(None, |a| Some(a + 1))
- /// # ;
+ /// # let r: Result<u32, &str> = Ok(1);
+ /// assert_eq!(Some(1), r.map_or(None, Some));
/// ```
- pub OPTION_MAP_OR_NONE,
+ ///
+ /// Good:
+ /// ```rust
+ /// # let r: Result<u32, &str> = Ok(1);
+ /// assert_eq!(Some(1), r.ok());
+ /// ```
+ pub RESULT_MAP_OR_INTO_OPTION,
style,
- "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
+ "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`.
+ /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or
+ /// `_.or_else(|x| Err(y))`.
///
/// **Why is this bad?** Readability, this can be written more concisely as
- /// `_.map(|x| y)`.
+ /// `_.map(|x| y)` or `_.map_err(|x| y)`.
///
/// **Known problems:** None
///
/// **Example:**
///
/// ```rust
- /// let x = Some("foo");
- /// let _ = x.and_then(|s| Some(s.len()));
+ /// # fn opt() -> Option<&'static str> { Some("42") }
+ /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+ /// let _ = opt().and_then(|s| Some(s.len()));
+ /// let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });
+ /// let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });
/// ```
///
/// The correct use would be:
///
/// ```rust
- /// let x = Some("foo");
- /// let _ = x.map(|s| s.len());
+ /// # fn opt() -> Option<&'static str> { Some("42") }
+ /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+ /// let _ = opt().map(|s| s.len());
+ /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
+ /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
/// ```
- pub OPTION_AND_THEN_SOME,
+ pub BIND_INSTEAD_OF_MAP,
complexity,
"using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
}
/// **What it does:** Checks for usage of `_.map(_).flatten(_)`,
///
/// **Why is this bad?** Readability, this can be written more concisely as a
- /// single method call.
+ /// single method call using `_.flat_map(_)`
///
/// **Known problems:**
///
/// **Example:**
/// ```rust
/// let vec = vec![vec![1]];
+ ///
+ /// // Bad
/// vec.iter().map(|x| x.iter()).flatten();
+ ///
+ /// // Good
+ /// vec.iter().flat_map(|x| x.iter());
/// ```
pub MAP_FLATTEN,
pedantic,
/// **Example:**
/// ```rust
/// let vec = vec![1];
+ ///
+ /// // Bad
/// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
+ ///
+ /// // Good
+ /// vec.iter().filter_map(|x| if *x == 0 {
+ /// Some(*x * 2)
+ /// } else {
+ /// None
+ /// });
/// ```
pub FILTER_MAP,
pedantic,
/// ```rust
/// # use std::rc::Rc;
/// let x = Rc::new(1);
+ ///
+ /// // Bad
/// x.clone();
+ ///
+ /// // Good
+ /// Rc::clone(&x);
/// ```
pub CLONE_ON_REF_PTR,
restriction,
/// ["foo", "bar"].iter().map(|&s| s.to_string());
/// ```
pub INEFFICIENT_TO_STRING,
- perf,
+ pedantic,
"using `to_string` on `&&T` where `T: ToString`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for `new` not returning `Self`.
+ /// **What it does:** Checks for `new` not returning a type that contains `Self`.
///
/// **Why is this bad?** As a convention, `new` methods are used to make a new
/// instance of a type.
/// }
/// }
/// ```
+ ///
+ /// ```rust
+ /// # struct Foo;
+ /// # struct FooError;
+ /// impl Foo {
+ /// // Good. Return type contains `Self`
+ /// fn new() -> Result<Foo, FooError> {
+ /// # Ok(Foo)
+ /// }
+ /// }
+ /// ```
+ ///
+ /// ```rust
+ /// # struct Foo;
+ /// struct Bar(Foo);
+ /// impl Foo {
+ /// // Bad. The type name must contain `Self`.
+ /// fn new() -> Bar {
+ /// # Bar(Foo)
+ /// }
+ /// }
+ /// ```
pub NEW_RET_NO_SELF,
style,
- "not returning `Self` in a `new` method"
+ "not returning type containing `Self` in a `new` method"
}
declare_clippy_lint! {
/// **Known problems:** Does not catch multi-byte unicode characters.
///
/// **Example:**
- /// `_.split("x")` could be `_.split('x')`
+ /// ```rust,ignore
+ /// // Bad
+ /// _.split("x");
+ ///
+ /// // Good
+ /// _.split('x');
pub SINGLE_CHAR_PATTERN,
perf,
"using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
}
declare_clippy_lint! {
- /// **What it does:** Checks for usage of `.chars().last()` or
- /// `.chars().next_back()` on a `str` to check if it ends with a given char.
+ /// **What it does:** Checks for usage of `_.chars().last()` or
+ /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
///
/// **Why is this bad?** Readability, this can be written more concisely as
/// `_.ends_with(_)`.
/// **Example:**
/// ```rust
/// # let name = "_";
- /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-')
- /// # ;
+ ///
+ /// // Bad
+ /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+ ///
+ /// // Good
+ /// name.ends_with('_') || name.ends_with('-');
/// ```
pub CHARS_LAST_CMP,
style,
/// **Example:**
/// ```rust
/// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
- /// ```
- /// As there is no transformation of the argument this could be written as:
- /// ```rust
+ ///
+ /// // As there is no transformation of the argument this could be written as:
/// let _ = (0..3).filter(|&x| x > 2);
/// ```
///
/// ```rust
/// let _ = (0..4).filter_map(|x| Some(x + 1));
- /// ```
- /// As there is no conditional check on the argument this could be written as:
- /// ```rust
+ ///
+ /// // As there is no conditional check on the argument this could be written as:
/// let _ = (0..4).map(|x| x + 1);
/// ```
pub UNNECESSARY_FILTER_MAP,
/// **Example:**
///
/// ```rust
+ /// // Bad
/// let _ = (&vec![3, 4, 5]).into_iter();
+ ///
+ /// // Good
+ /// let _ = (&vec![3, 4, 5]).iter();
/// ```
pub INTO_ITER_ON_REF,
style,
/// ```rust
/// # let y: u32 = 0;
/// # let x: u32 = 100;
- /// let add = x.checked_add(y).unwrap_or(u32::max_value());
- /// let sub = x.checked_sub(y).unwrap_or(u32::min_value());
+ /// let add = x.checked_add(y).unwrap_or(u32::MAX);
+ /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
/// ```
///
/// can be written using dedicated methods for saturating addition/subtraction as:
"using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
}
+declare_clippy_lint! {
+ /// **What it does:** Checks for usage of `iter().next()` on a Slice or an Array
+ ///
+ /// **Why is this bad?** These can be shortened into `.get()`
+ ///
+ /// **Known problems:** None.
+ ///
+ /// **Example:**
+ /// ```rust
+ /// # let a = [1, 2, 3];
+ /// # let b = vec![1, 2, 3];
+ /// a[2..].iter().next();
+ /// b.iter().next();
+ /// ```
+ /// should be written as:
+ /// ```rust
+ /// # let a = [1, 2, 3];
+ /// # let b = vec![1, 2, 3];
+ /// a.get(2);
+ /// b.get(0);
+ /// ```
+ pub ITER_NEXT_SLICE,
+ style,
+ "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
+}
+
declare_lint_pass!(Methods => [
- OPTION_UNWRAP_USED,
- RESULT_UNWRAP_USED,
- OPTION_EXPECT_USED,
- RESULT_EXPECT_USED,
+ UNWRAP_USED,
+ EXPECT_USED,
SHOULD_IMPLEMENT_TRAIT,
WRONG_SELF_CONVENTION,
WRONG_PUB_SELF_CONVENTION,
OK_EXPECT,
- OPTION_MAP_UNWRAP_OR,
- OPTION_MAP_UNWRAP_OR_ELSE,
- RESULT_MAP_UNWRAP_OR_ELSE,
+ MAP_UNWRAP_OR,
+ RESULT_MAP_OR_INTO_OPTION,
OPTION_MAP_OR_NONE,
- OPTION_AND_THEN_SOME,
+ BIND_INSTEAD_OF_MAP,
OR_FUN_CALL,
EXPECT_FUN_CALL,
CHARS_NEXT_CMP,
FIND_MAP,
MAP_FLATTEN,
ITERATOR_STEP_BY_ZERO,
+ ITER_NEXT_SLICE,
ITER_NTH,
ITER_NTH_ZERO,
ITER_SKIP_NEXT,
OPTION_AS_REF_DEREF,
]);
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
- #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>) {
+impl<'tcx> LateLintPass<'tcx> for Methods {
+ #[allow(clippy::too_many_lines)]
+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
if in_macro(expr.span) {
return;
}
["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
["unwrap_or_else", "map"] => lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]),
["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
- ["and_then", ..] => lint_option_and_then_some(cx, expr, arg_lists[0]),
+ ["and_then", ..] => {
+ bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
+ bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
+ },
+ ["or_else", ..] => {
+ bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]);
+ },
["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
+ ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1]),
lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
},
["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
- ["as_ptr", "unwrap"] | ["as_ptr", "expect"] => {
- lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0])
- },
+ ["as_ptr", "unwrap" | "expect"] => lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0]),
["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
["filter_map", ..] => unnecessary_filter_map::lint(cx, expr, arg_lists[0]),
["count", "map"] => lint_suspicious_map(cx, expr),
["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
- ["unwrap_or", arith @ "checked_add"]
- | ["unwrap_or", arith @ "checked_sub"]
- | ["unwrap_or", arith @ "checked_mul"] => {
+ ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
},
- ["add"] | ["offset"] | ["sub"] | ["wrapping_offset"] | ["wrapping_add"] | ["wrapping_sub"] => {
+ ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
check_pointer_offset(cx, expr, arg_lists[0])
},
["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
}
match expr.kind {
- hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args) => {
+ hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
- let self_ty = cx.tables.expr_ty_adjusted(&args[0]);
+ let self_ty = cx.tables().expr_ty_adjusted(&args[0]);
if args.len() == 1 && method_call.ident.name == sym!(clone) {
lint_clone_on_copy(cx, expr, &args[0], self_ty);
lint_clone_on_ref_ptr(cx, expr, &args[0]);
}
}
- fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
+ fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
if in_external_macro(cx.sess(), impl_item.span) {
return;
}
let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id);
let item = cx.tcx.hir().expect_item(parent);
let def_id = cx.tcx.hir().local_def_id(item.hir_id);
- let ty = cx.tcx.type_of(def_id);
+ let self_ty = cx.tcx.type_of(def_id);
if_chain! {
if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next();
then {
if cx.access_levels.is_exported(impl_item.hir_id) {
// check missing trait implementations
- for &(method_name, n_args, self_kind, out_type, trait_name) in &TRAIT_METHODS {
+ for &(method_name, n_args, fn_header, self_kind, out_type, trait_name) in &TRAIT_METHODS {
if name == method_name &&
- sig.decl.inputs.len() == n_args &&
- out_type.matches(cx, &sig.decl.output) &&
- self_kind.matches(cx, ty, first_arg_ty) {
+ sig.decl.inputs.len() == n_args &&
+ out_type.matches(cx, &sig.decl.output) &&
+ self_kind.matches(cx, self_ty, first_arg_ty) &&
+ fn_header_equals(*fn_header, sig.header) {
span_lint(cx, SHOULD_IMPLEMENT_TRAIT, impl_item.span, &format!(
"defining a method called `{}` on this type; consider implementing \
the `{}` trait or choosing a less ambiguous name", name, trait_name));
.iter()
.find(|(ref conv, _)| conv.check(&name))
{
- if !self_kinds.iter().any(|k| k.matches(cx, ty, first_arg_ty)) {
+ if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
let lint = if item.vis.node.is_pub() {
WRONG_PUB_SELF_CONVENTION
} else {
cx,
lint,
first_arg.pat.span,
- &format!(
- "methods called `{}` usually take {}; consider choosing a less \
- ambiguous name",
+ &format!("methods called `{}` usually take {}; consider choosing a less ambiguous name",
conv,
&self_kinds
.iter()
if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
let ret_ty = return_ty(cx, impl_item.hir_id);
+ let contains_self_ty = |ty: Ty<'tcx>| {
+ ty.walk().any(|inner| match inner.unpack() {
+ GenericArgKind::Type(inner_ty) => TyS::same_type(self_ty, inner_ty),
+
+ GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+ })
+ };
+
// walk the return type and check for Self (this does not check associated types)
- if ret_ty.walk().any(|inner_type| same_tys(cx, ty, inner_type)) {
+ if contains_self_ty(ret_ty) {
return;
}
if let ty::Opaque(def_id, _) = ret_ty.kind {
// one of the associated types must be Self
for predicate in cx.tcx.predicates_of(def_id).predicates {
- match predicate {
- (Predicate::Projection(poly_projection_predicate), _) => {
- let binder = poly_projection_predicate.ty();
- let associated_type = binder.skip_binder();
-
- // walk the associated type and check for Self
- for inner_type in associated_type.walk() {
- if same_tys(cx, ty, inner_type) {
- return;
- }
- }
- },
- (_, _) => {},
+ if let ty::PredicateKind::Projection(poly_projection_predicate) = predicate.0.kind() {
+ let binder = poly_projection_predicate.ty();
+ let associated_type = binder.skip_binder();
+
+ // walk the associated type and check for Self
+ if contains_self_ty(associated_type) {
+ return;
+ }
}
}
}
- if name == "new" && !same_tys(cx, ret_ty, ty) {
+ if name == "new" && !TyS::same_type(ret_ty, self_ty) {
span_lint(
cx,
NEW_RET_NO_SELF,
/// Checks for the `OR_FUN_CALL` lint.
#[allow(clippy::too_many_lines)]
-fn lint_or_fun_call<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_or_fun_call<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &hir::Expr<'_>,
method_span: Span,
name: &str,
) {
// Searches an expression for method calls or function calls that aren't ctors
struct FunCallFinder<'a, 'tcx> {
- cx: &'a LateContext<'a, 'tcx>,
+ cx: &'a LateContext<'tcx>,
found: bool,
}
/// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
fn check_unwrap_or_default(
- cx: &LateContext<'_, '_>,
+ cx: &LateContext<'_>,
name: &str,
fun: &hir::Expr<'_>,
self_expr: &hir::Expr<'_>,
if let hir::ExprKind::Path(ref qpath) = fun.kind;
let path = &*last_path_segment(qpath).ident.as_str();
if ["default", "new"].contains(&path);
- let arg_ty = cx.tables.expr_ty(arg);
+ let arg_ty = cx.tables().expr_ty(arg);
if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
if implements_trait(cx, arg_ty, default_trait_id, &[]);
/// Checks for `*or(foo())`.
#[allow(clippy::too_many_arguments)]
- fn check_general_case<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+ fn check_general_case<'tcx>(
+ cx: &LateContext<'tcx>,
name: &str,
method_span: Span,
fun_span: Span,
or_has_args: bool,
span: Span,
) {
+ if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
+ if path.ident.as_str() == "len" {
+ let ty = walk_ptrs_ty(cx.tables().expr_ty(&args[0]));
+
+ match ty.kind {
+ ty::Slice(_) | ty::Array(_, _) => return,
+ _ => (),
+ }
+
+ if match_type(cx, ty, &paths::VEC) {
+ return;
+ }
+ }
+ }
+
// (path, fn_has_argument, methods, suffix)
let know_types: &[(&[_], _, &[_], _)] = &[
(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
if { finder.visit_expr(&arg); finder.found };
if !contains_return(&arg);
- let self_ty = cx.tables.expr_ty(self_expr);
+ let self_ty = cx.tables().expr_ty(self_expr);
if let Some(&(_, fn_has_arguments, poss, suffix)) =
- know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
+ know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
if poss.contains(&name);
);
}
},
- hir::ExprKind::MethodCall(_, span, ref or_args) => check_general_case(
+ hir::ExprKind::MethodCall(_, span, ref or_args, _) => check_general_case(
cx,
name,
method_span,
/// Checks for the `EXPECT_FUN_CALL` lint.
#[allow(clippy::too_many_lines)]
fn lint_expect_fun_call(
- cx: &LateContext<'_, '_>,
+ cx: &LateContext<'_>,
expr: &hir::Expr<'_>,
method_span: Span,
name: &str,
) {
// Strip `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
// `&str`
- fn get_arg_root<'a>(cx: &LateContext<'_, '_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+ fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
let mut arg_root = arg;
loop {
arg_root = match &arg_root.kind {
hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
- hir::ExprKind::MethodCall(method_name, _, call_args) => {
+ hir::ExprKind::MethodCall(method_name, _, call_args, _) => {
if call_args.len() == 1
&& (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref))
&& {
- let arg_type = cx.tables.expr_ty(&call_args[0]);
+ let arg_type = cx.tables().expr_ty(&call_args[0]);
let base_type = walk_ptrs_ty(arg_type);
- base_type.kind == ty::Str || match_type(cx, base_type, &paths::STRING)
+ base_type.kind == ty::Str || is_type_diagnostic_item(cx, base_type, sym!(string_type))
}
{
&call_args[0]
// Only `&'static str` or `String` can be used directly in the `panic!`. Other types should be
// converted to string.
- fn requires_to_string(cx: &LateContext<'_, '_>, arg: &hir::Expr<'_>) -> bool {
- let arg_ty = cx.tables.expr_ty(arg);
- if match_type(cx, arg_ty, &paths::STRING) {
+ fn requires_to_string(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
+ let arg_ty = cx.tables().expr_ty(arg);
+ if is_type_diagnostic_item(cx, arg_ty, sym!(string_type)) {
return false;
}
if let ty::Ref(_, ty, ..) = arg_ty.kind {
// Check if an expression could have type `&'static str`, knowing that it
// has type `&str` for some lifetime.
- fn can_be_static_str(cx: &LateContext<'_, '_>, arg: &hir::Expr<'_>) -> bool {
+ fn can_be_static_str(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
match arg.kind {
hir::ExprKind::Lit(_) => true,
hir::ExprKind::Call(fun, _) => {
if let hir::ExprKind::Path(ref p) = fun.kind {
- match cx.tables.qpath_res(p, fun.hir_id) {
- hir::def::Res::Def(hir::def::DefKind::Fn, def_id)
- | hir::def::Res::Def(hir::def::DefKind::AssocFn, def_id) => matches!(
+ match cx.qpath_res(p, fun.hir_id) {
+ hir::def::Res::Def(hir::def::DefKind::Fn | hir::def::DefKind::AssocFn, def_id) => matches!(
cx.tcx.fn_sig(def_id).output().skip_binder().kind,
ty::Ref(ty::ReStatic, ..)
),
false
}
},
- hir::ExprKind::MethodCall(..) => cx.tables.type_dependent_def_id(arg.hir_id).map_or(false, |method_id| {
- matches!(
- cx.tcx.fn_sig(method_id).output().skip_binder().kind,
- ty::Ref(ty::ReStatic, ..)
- )
- }),
- hir::ExprKind::Path(ref p) => match cx.tables.qpath_res(p, arg.hir_id) {
+ hir::ExprKind::MethodCall(..) => cx
+ .tables()
+ .type_dependent_def_id(arg.hir_id)
+ .map_or(false, |method_id| {
+ matches!(
+ cx.tcx.fn_sig(method_id).output().skip_binder().kind,
+ ty::Ref(ty::ReStatic, ..)
+ )
+ }),
+ hir::ExprKind::Path(ref p) => match cx.qpath_res(p, arg.hir_id) {
hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _) => true,
_ => false,
},
}
fn generate_format_arg_snippet(
- cx: &LateContext<'_, '_>,
+ cx: &LateContext<'_>,
a: &hir::Expr<'_>,
applicability: &mut Applicability,
) -> Vec<String> {
return;
}
- let receiver_type = cx.tables.expr_ty_adjusted(&args[0]);
- let closure_args = if match_type(cx, receiver_type, &paths::OPTION) {
+ let receiver_type = cx.tables().expr_ty_adjusted(&args[0]);
+ let closure_args = if is_type_diagnostic_item(cx, receiver_type, sym!(option_type)) {
"||"
- } else if match_type(cx, receiver_type, &paths::RESULT) {
+ } else if is_type_diagnostic_item(cx, receiver_type, sym!(result_type)) {
"|_|"
} else {
return;
}
/// Checks for the `CLONE_ON_COPY` lint.
-fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'_>) {
- let ty = cx.tables.expr_ty(expr);
+fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'_>) {
+ let ty = cx.tables().expr_ty(expr);
if let ty::Ref(_, inner, _) = arg_ty.kind {
if let ty::Ref(_, innermost, _) = inner.kind {
span_lint_and_then(
CLONE_DOUBLE_REF,
expr.span,
"using `clone` on a double-reference; \
- this will copy the reference instead of cloning the inner type",
- |db| {
+ this will copy the reference instead of cloning the inner type",
+ |diag| {
if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
let mut ty = innermost;
let mut n = 0;
}
let refs: String = iter::repeat('&').take(n + 1).collect();
let derefs: String = iter::repeat('*').take(n).collect();
- let explicit = format!("{}{}::clone({})", refs, ty, snip);
- db.span_suggestion(
+ let explicit = format!("<{}{}>::clone({})", refs, ty, snip);
+ diag.span_suggestion(
expr.span,
"try dereferencing it",
format!("{}({}{}).clone()", refs, derefs, snip.deref()),
Applicability::MaybeIncorrect,
);
- db.span_suggestion(
+ diag.span_suggestion(
expr.span,
- "or try being explicit about what type to clone",
+ "or try being explicit if you are sure, that you want to clone a reference",
explicit,
Applicability::MaybeIncorrect,
);
match &cx.tcx.hir().get(parent) {
hir::Node::Expr(parent) => match parent.kind {
// &*x is a nop, &x.clone() is not
- hir::ExprKind::AddrOf(..) |
+ hir::ExprKind::AddrOf(..) => return,
// (*x).func() is useless, x.clone().func() can work in case func borrows mutably
- hir::ExprKind::MethodCall(..) => return,
+ hir::ExprKind::MethodCall(_, _, parent_args, _) if expr.hir_id == parent_args[0].hir_id => return,
+
_ => {},
},
hir::Node::Stmt(stmt) => {
}
// x.clone() might have dereferenced x, possibly through Deref impls
- if cx.tables.expr_ty(arg) == ty {
+ if cx.tables().expr_ty(arg) == ty {
snip = Some(("try removing the `clone` call", format!("{}", snippet)));
} else {
let deref_count = cx
- .tables
+ .tables()
.expr_adjustments(arg)
.iter()
.filter(|adj| {
} else {
snip = None;
}
- span_lint_and_then(cx, CLONE_ON_COPY, expr.span, "using `clone` on a `Copy` type", |db| {
+ span_lint_and_then(cx, CLONE_ON_COPY, expr.span, "using `clone` on a `Copy` type", |diag| {
if let Some((text, snip)) = snip {
- db.span_suggestion(expr.span, text, snip, Applicability::Unspecified);
+ diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
}
});
}
}
-fn lint_clone_on_ref_ptr(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
- let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(arg));
+fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+ let obj_ty = walk_ptrs_ty(cx.tables().expr_ty(arg));
if let ty::Adt(_, subst) = obj_ty.kind {
- let caller_type = if match_type(cx, obj_ty, &paths::RC) {
+ let caller_type = if is_type_diagnostic_item(cx, obj_ty, sym::Rc) {
"Rc"
- } else if match_type(cx, obj_ty, &paths::ARC) {
+ } else if is_type_diagnostic_item(cx, obj_ty, sym::Arc) {
"Arc"
} else if match_type(cx, obj_ty, &paths::WEAK_RC) || match_type(cx, obj_ty, &paths::WEAK_ARC) {
"Weak"
}
}
-fn lint_string_extend(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
let arg = &args[1];
if let Some(arglists) = method_chain_args(arg, &["chars"]) {
let target = &arglists[0][0];
- let self_ty = walk_ptrs_ty(cx.tables.expr_ty(target));
+ let self_ty = walk_ptrs_ty(cx.tables().expr_ty(target));
let ref_str = if self_ty.kind == ty::Str {
""
- } else if match_type(cx, self_ty, &paths::STRING) {
+ } else if is_type_diagnostic_item(cx, self_ty, sym!(string_type)) {
"&"
} else {
return;
}
}
-fn lint_extend(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
- let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&args[0]));
- if match_type(cx, obj_ty, &paths::STRING) {
+fn lint_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+ let obj_ty = walk_ptrs_ty(cx.tables().expr_ty(&args[0]));
+ if is_type_diagnostic_item(cx, obj_ty, sym!(string_type)) {
lint_string_extend(cx, expr, args);
}
}
-fn lint_cstring_as_ptr(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, source: &hir::Expr<'_>, unwrap: &hir::Expr<'_>) {
+fn lint_cstring_as_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, source: &hir::Expr<'_>, unwrap: &hir::Expr<'_>) {
if_chain! {
- let source_type = cx.tables.expr_ty(source);
+ let source_type = cx.tables().expr_ty(source);
if let ty::Adt(def, substs) = source_type.kind;
- if match_def_path(cx, def.did, &paths::RESULT);
+ if cx.tcx.is_diagnostic_item(sym!(result_type), def.did);
if match_type(cx, substs.type_at(0), &paths::CSTRING);
then {
span_lint_and_then(
TEMPORARY_CSTRING_AS_PTR,
expr.span,
"you are getting the inner pointer of a temporary `CString`",
- |db| {
- db.note("that pointer will be invalid outside this expression");
- db.span_help(unwrap.span, "assign the `CString` to a variable to extend its lifetime");
+ |diag| {
+ diag.note("that pointer will be invalid outside this expression");
+ diag.span_help(unwrap.span, "assign the `CString` to a variable to extend its lifetime");
});
}
}
}
-fn lint_iter_cloned_collect<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- expr: &hir::Expr<'_>,
- iter_args: &'tcx [hir::Expr<'_>],
-) {
+fn lint_iter_cloned_collect<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
if_chain! {
- if is_type_diagnostic_item(cx, cx.tables.expr_ty(expr), Symbol::intern("vec_type"));
- if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0]));
+ if is_type_diagnostic_item(cx, cx.tables().expr_ty(expr), sym!(vec_type));
+ if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.tables().expr_ty(&iter_args[0]));
if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
then {
ITER_CLONED_COLLECT,
to_replace,
"called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
- more readable",
+ more readable",
"try",
".to_vec()".to_string(),
Applicability::MachineApplicable,
}
}
-fn lint_unnecessary_fold(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
+fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
fn check_fold_with_op(
- cx: &LateContext<'_, '_>,
+ cx: &LateContext<'_>,
expr: &hir::Expr<'_>,
fold_args: &[hir::Expr<'_>],
fold_span: Span,
}
}
-fn lint_step_by<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
+fn lint_step_by<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
if match_trait_method(cx, expr, &paths::ITERATOR) {
- if let Some((Constant::Int(0), _)) = constant(cx, cx.tables, &args[1]) {
+ if let Some((Constant::Int(0), _)) = constant(cx, cx.tables(), &args[1]) {
span_lint(
cx,
ITERATOR_STEP_BY_ZERO,
}
}
-fn lint_iter_nth<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
+ let caller_expr = &iter_args[0];
+
+ // Skip lint if the `iter().next()` expression is a for loop argument,
+ // since it is already covered by `&loops::ITER_NEXT_LOOP`
+ let mut parent_expr_opt = get_parent_expr(cx, expr);
+ while let Some(parent_expr) = parent_expr_opt {
+ if higher::for_loop(parent_expr).is_some() {
+ return;
+ }
+ parent_expr_opt = get_parent_expr(cx, parent_expr);
+ }
+
+ if derefs_to_slice(cx, caller_expr, cx.tables().expr_ty(caller_expr)).is_some() {
+ // caller is a Slice
+ if_chain! {
+ if let hir::ExprKind::Index(ref caller_var, ref index_expr) = &caller_expr.kind;
+ if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
+ = higher::range(cx, index_expr);
+ if let hir::ExprKind::Lit(ref start_lit) = &start_expr.kind;
+ if let ast::LitKind::Int(start_idx, _) = start_lit.node;
+ then {
+ let mut applicability = Applicability::MachineApplicable;
+ span_lint_and_sugg(
+ cx,
+ ITER_NEXT_SLICE,
+ expr.span,
+ "Using `.iter().next()` on a Slice without end index.",
+ "try calling",
+ format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
+ applicability,
+ );
+ }
+ }
+ } else if is_type_diagnostic_item(cx, cx.tables().expr_ty(caller_expr), sym!(vec_type))
+ || matches!(&walk_ptrs_ty(cx.tables().expr_ty(caller_expr)).kind, ty::Array(_, _))
+ {
+ // caller is a Vec or an Array
+ let mut applicability = Applicability::MachineApplicable;
+ span_lint_and_sugg(
+ cx,
+ ITER_NEXT_SLICE,
+ expr.span,
+ "Using `.iter().next()` on an array",
+ "try calling",
+ format!(
+ "{}.get(0)",
+ snippet_with_applicability(cx, caller_expr.span, "..", &mut applicability)
+ ),
+ applicability,
+ );
+ }
+}
+
+fn lint_iter_nth<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &hir::Expr<'_>,
nth_and_iter_args: &[&'tcx [hir::Expr<'tcx>]],
is_mut: bool,
) {
let iter_args = nth_and_iter_args[1];
let mut_str = if is_mut { "_mut" } else { "" };
- let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.tables.expr_ty(&iter_args[0])).is_some() {
+ let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.tables().expr_ty(&iter_args[0])).is_some() {
"slice"
- } else if is_type_diagnostic_item(cx, cx.tables.expr_ty(&iter_args[0]), Symbol::intern("vec_type")) {
+ } else if is_type_diagnostic_item(cx, cx.tables().expr_ty(&iter_args[0]), sym!(vec_type)) {
"Vec"
- } else if match_type(cx, cx.tables.expr_ty(&iter_args[0]), &paths::VEC_DEQUE) {
+ } else if is_type_diagnostic_item(cx, cx.tables().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
"VecDeque"
} else {
let nth_args = nth_and_iter_args[0];
ITER_NTH,
expr.span,
&format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
+ None,
&format!("calling `.get{}()` is both faster and more readable", mut_str),
);
}
-fn lint_iter_nth_zero<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
+fn lint_iter_nth_zero<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
if_chain! {
if match_trait_method(cx, expr, &paths::ITERATOR);
- if let Some((Constant::Int(0), _)) = constant(cx, cx.tables, &nth_args[1]);
+ if let Some((Constant::Int(0), _)) = constant(cx, cx.tables(), &nth_args[1]);
then {
let mut applicability = Applicability::MachineApplicable;
span_lint_and_sugg(
}
}
-fn lint_get_unwrap<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- expr: &hir::Expr<'_>,
- get_args: &'tcx [hir::Expr<'_>],
- is_mut: bool,
-) {
+fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args: &'tcx [hir::Expr<'_>], is_mut: bool) {
// Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
// because they do not implement `IndexMut`
let mut applicability = Applicability::MachineApplicable;
- let expr_ty = cx.tables.expr_ty(&get_args[0]);
+ let expr_ty = cx.tables().expr_ty(&get_args[0]);
let get_args_str = if get_args.len() > 1 {
snippet_with_applicability(cx, get_args[1].span, "_", &mut applicability)
} else {
let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
needs_ref = get_args_str.parse::<usize>().is_ok();
"slice"
- } else if is_type_diagnostic_item(cx, expr_ty, Symbol::intern("vec_type")) {
+ } else if is_type_diagnostic_item(cx, expr_ty, sym!(vec_type)) {
needs_ref = get_args_str.parse::<usize>().is_ok();
"Vec"
- } else if match_type(cx, expr_ty, &paths::VEC_DEQUE) {
+ } else if is_type_diagnostic_item(cx, expr_ty, sym!(vecdeque_type)) {
needs_ref = get_args_str.parse::<usize>().is_ok();
"VecDeque"
- } else if !is_mut && match_type(cx, expr_ty, &paths::HASHMAP) {
+ } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym!(hashmap_type)) {
needs_ref = true;
"HashMap"
} else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
);
}
-fn lint_iter_skip_next(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
+fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
// lint if caller of skip is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) {
span_lint_and_help(
ITER_SKIP_NEXT,
expr.span,
"called `skip(x).next()` on an iterator",
+ None,
"this is more succinctly expressed by calling `nth(x)`",
);
}
}
-fn derefs_to_slice<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn derefs_to_slice<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'tcx>,
ty: Ty<'tcx>,
) -> Option<&'tcx hir::Expr<'tcx>> {
- fn may_slice<'a>(cx: &LateContext<'_, 'a>, ty: Ty<'a>) -> bool {
+ fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
match ty.kind {
ty::Slice(_) => true,
ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
- ty::Adt(..) => is_type_diagnostic_item(cx, ty, Symbol::intern("vec_type")),
+ ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym!(vec_type)),
ty::Array(_, size) => {
if let Some(size) = size.try_eval_usize(cx.tcx, cx.param_env) {
size < 32
}
}
- if let hir::ExprKind::MethodCall(ref path, _, ref args) = expr.kind {
- if path.ident.name == sym!(iter) && may_slice(cx, cx.tables.expr_ty(&args[0])) {
+ if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
+ if path.ident.name == sym!(iter) && may_slice(cx, cx.tables().expr_ty(&args[0])) {
Some(&args[0])
} else {
None
}
/// lint use of `unwrap()` for `Option`s and `Result`s
-fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
- let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&unwrap_args[0]));
+fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
+ let obj_ty = walk_ptrs_ty(cx.tables().expr_ty(&unwrap_args[0]));
- let mess = if match_type(cx, obj_ty, &paths::OPTION) {
- Some((OPTION_UNWRAP_USED, "an Option", "None"))
- } else if match_type(cx, obj_ty, &paths::RESULT) {
- Some((RESULT_UNWRAP_USED, "a Result", "Err"))
+ let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
+ Some((UNWRAP_USED, "an Option", "None"))
+ } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
+ Some((UNWRAP_USED, "a Result", "Err"))
} else {
None
};
lint,
expr.span,
&format!("used `unwrap()` on `{}` value", kind,),
+ None,
&format!(
"if you don't want to handle the `{}` case gracefully, consider \
- using `expect()` to provide a better panic message",
+ using `expect()` to provide a better panic message",
none_value,
),
);
}
/// lint use of `expect()` for `Option`s and `Result`s
-fn lint_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
- let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&expect_args[0]));
+fn lint_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
+ let obj_ty = walk_ptrs_ty(cx.tables().expr_ty(&expect_args[0]));
- let mess = if match_type(cx, obj_ty, &paths::OPTION) {
- Some((OPTION_EXPECT_USED, "an Option", "None"))
- } else if match_type(cx, obj_ty, &paths::RESULT) {
- Some((RESULT_EXPECT_USED, "a Result", "Err"))
+ let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
+ Some((EXPECT_USED, "an Option", "None"))
+ } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
+ Some((EXPECT_USED, "a Result", "Err"))
} else {
None
};
lint,
expr.span,
&format!("used `expect()` on `{}` value", kind,),
+ None,
&format!("if this value is an `{}`, it will panic", none_value,),
);
}
}
/// lint use of `ok().expect()` for `Result`s
-fn lint_ok_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
+fn lint_ok_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
if_chain! {
// lint if the caller of `ok()` is a `Result`
- if match_type(cx, cx.tables.expr_ty(&ok_args[0]), &paths::RESULT);
- let result_type = cx.tables.expr_ty(&ok_args[0]);
+ if is_type_diagnostic_item(cx, cx.tables().expr_ty(&ok_args[0]), sym!(result_type));
+ let result_type = cx.tables().expr_ty(&ok_args[0]);
if let Some(error_type) = get_error_type(cx, result_type);
if has_debug_impl(error_type, cx);
OK_EXPECT,
expr.span,
"called `ok().expect()` on a `Result` value",
+ None,
"you can call `expect()` directly on the `Result`",
);
}
}
}
-/// lint use of `map().flatten()` for `Iterators`
-fn lint_map_flatten<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
+/// lint use of `map().flatten()` for `Iterators` and 'Options'
+fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
// lint if caller of `.map().flatten()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `map(..).flatten()` on an `Iterator`. \
- This is more succinctly expressed by calling `.flat_map(..)`";
+ This is more succinctly expressed by calling `.flat_map(..)`";
let self_snippet = snippet(cx, map_args[0].span, "..");
let func_snippet = snippet(cx, map_args[1].span, "..");
let hint = format!("{0}.flat_map({1})", self_snippet, func_snippet);
Applicability::MachineApplicable,
);
}
+
+ // lint if caller of `.map().flatten()` is an Option
+ if is_type_diagnostic_item(cx, cx.tables().expr_ty(&map_args[0]), sym!(option_type)) {
+ let msg = "called `map(..).flatten()` on an `Option`. \
+ This is more succinctly expressed by calling `.and_then(..)`";
+ let self_snippet = snippet(cx, map_args[0].span, "..");
+ let func_snippet = snippet(cx, map_args[1].span, "..");
+ let hint = format!("{0}.and_then({1})", self_snippet, func_snippet);
+ span_lint_and_sugg(
+ cx,
+ MAP_FLATTEN,
+ expr.span,
+ msg,
+ "try using `and_then` instead",
+ hint,
+ Applicability::MachineApplicable,
+ );
+ }
}
/// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
-fn lint_map_unwrap_or_else<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_map_unwrap_or_else<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
map_args: &'tcx [hir::Expr<'_>],
unwrap_args: &'tcx [hir::Expr<'_>],
) {
// lint if the caller of `map()` is an `Option`
- let is_option = match_type(cx, cx.tables.expr_ty(&map_args[0]), &paths::OPTION);
- let is_result = match_type(cx, cx.tables.expr_ty(&map_args[0]), &paths::RESULT);
+ let is_option = is_type_diagnostic_item(cx, cx.tables().expr_ty(&map_args[0]), sym!(option_type));
+ let is_result = is_type_diagnostic_item(cx, cx.tables().expr_ty(&map_args[0]), sym!(result_type));
if is_option || is_result {
// Don't make a suggestion that may fail to compile due to mutably borrowing
// lint message
let msg = if is_option {
"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"
+ `map_or_else(g, f)` instead"
} else {
"called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling \
- `.map_or_else(g, f)` instead"
+ `.map_or_else(g, f)` instead"
};
// get snippets for args to map() and unwrap_or_else()
let map_snippet = snippet(cx, map_args[1].span, "..");
if same_span && !multiline {
span_lint_and_note(
cx,
- if is_option {
- OPTION_MAP_UNWRAP_OR_ELSE
- } else {
- RESULT_MAP_UNWRAP_OR_ELSE
- },
+ MAP_UNWRAP_OR,
expr.span,
msg,
- expr.span,
+ None,
&format!(
"replace `map({0}).unwrap_or_else({1})` with `map_or_else({1}, {0})`",
map_snippet, unwrap_snippet,
),
);
} else if same_span && multiline {
- span_lint(
- cx,
- if is_option {
- OPTION_MAP_UNWRAP_OR_ELSE
- } else {
- RESULT_MAP_UNWRAP_OR_ELSE
- },
- expr.span,
- msg,
- );
+ span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
};
}
}
-/// 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::ExprKind::Path(ref qpath) = map_or_args[1].kind {
+/// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
+fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_or_args: &'tcx [hir::Expr<'_>]) {
+ let is_option = is_type_diagnostic_item(cx, cx.tables().expr_ty(&map_or_args[0]), sym!(option_type));
+ let is_result = is_type_diagnostic_item(cx, cx.tables().expr_ty(&map_or_args[0]), sym!(result_type));
+
+ // There are two variants of this `map_or` lint:
+ // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
+ // (2) using `map_or` as a combinator instead of `and_then`
+ //
+ // (For this lint) we don't care if any other type calls `map_or`
+ if !is_option && !is_result {
+ return;
+ }
+
+ let (lint_name, msg, instead, hint) = {
+ let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].kind {
match_qpath(qpath, &paths::OPTION_NONE)
+ } else {
+ return;
+ };
+
+ if !default_arg_is_none {
+ // nothing to lint!
+ return;
+ }
+
+ let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_or_args[2].kind {
+ match_qpath(qpath, &paths::OPTION_SOME)
} else {
false
};
- if map_or_arg_is_none {
- // lint message
+ if is_option {
+ let self_snippet = snippet(cx, map_or_args[0].span, "..");
+ let func_snippet = snippet(cx, map_or_args[2].span, "..");
let msg = "called `map_or(None, f)` on an `Option` value. This can be done more directly by calling \
`and_then(f)` instead";
- 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_sugg(
- cx,
+ (
OPTION_MAP_OR_NONE,
- expr.span,
msg,
"try using `and_then` instead",
- hint,
- Applicability::MachineApplicable,
- );
+ format!("{0}.and_then({1})", self_snippet, func_snippet),
+ )
+ } else if f_arg_is_some {
+ let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
+ `ok()` instead";
+ let self_snippet = snippet(cx, map_or_args[0].span, "..");
+ (
+ RESULT_MAP_OR_INTO_OPTION,
+ msg,
+ "try using `ok` instead",
+ format!("{0}.ok()", self_snippet),
+ )
+ } else {
+ // nothing to lint!
+ return;
}
- }
-}
-
-/// Lint use of `_.and_then(|x| Some(y))` for `Option`s
-fn lint_option_and_then_some(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
- const LINT_MSG: &str = "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`";
- const NO_OP_MSG: &str = "using `Option.and_then(Some)`, which is a no-op";
-
- let ty = cx.tables.expr_ty(&args[0]);
- if !match_type(cx, ty, &paths::OPTION) {
- return;
- }
-
- match args[1].kind {
- hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
- let closure_body = cx.tcx.hir().body(body_id);
- let closure_expr = remove_blocks(&closure_body.value);
- if_chain! {
- if let hir::ExprKind::Call(ref some_expr, ref some_args) = closure_expr.kind;
- if let hir::ExprKind::Path(ref qpath) = some_expr.kind;
- if match_qpath(qpath, &paths::OPTION_SOME);
- if some_args.len() == 1;
- then {
- let inner_expr = &some_args[0];
-
- if contains_return(inner_expr) {
- return;
- }
-
- let some_inner_snip = if inner_expr.span.from_expansion() {
- snippet_with_macro_callsite(cx, inner_expr.span, "_")
- } else {
- snippet(cx, inner_expr.span, "_")
- };
+ };
- let closure_args_snip = snippet(cx, closure_args_span, "..");
- let option_snip = snippet(cx, args[0].span, "..");
- let note = format!("{}.map({} {})", option_snip, closure_args_snip, some_inner_snip);
- span_lint_and_sugg(
- cx,
- OPTION_AND_THEN_SOME,
- expr.span,
- LINT_MSG,
- "try this",
- note,
- Applicability::MachineApplicable,
- );
- }
- }
- },
- // `_.and_then(Some)` case, which is no-op.
- hir::ExprKind::Path(ref qpath) => {
- if match_qpath(qpath, &paths::OPTION_SOME) {
- let option_snip = snippet(cx, args[0].span, "..");
- let note = format!("{}", option_snip);
- span_lint_and_sugg(
- cx,
- OPTION_AND_THEN_SOME,
- expr.span,
- NO_OP_MSG,
- "use the expression directly",
- note,
- Applicability::MachineApplicable,
- );
- }
- },
- _ => {},
- }
+ span_lint_and_sugg(
+ cx,
+ lint_name,
+ expr.span,
+ msg,
+ instead,
+ hint,
+ Applicability::MachineApplicable,
+ );
}
/// lint use of `filter().next()` for `Iterators`
-fn lint_filter_next<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- expr: &'tcx hir::Expr<'_>,
- filter_args: &'tcx [hir::Expr<'_>],
-) {
+fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
// lint if caller of `.filter().next()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
FILTER_NEXT,
expr.span,
msg,
- expr.span,
+ None,
&format!("replace `filter({0}).next()` with `find({0})`", filter_snippet),
);
} else {
}
/// lint use of `skip_while().next()` for `Iterators`
-fn lint_skip_while_next<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_skip_while_next<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_skip_while_args: &'tcx [hir::Expr<'_>],
) {
SKIP_WHILE_NEXT,
expr.span,
"called `skip_while(p).next()` on an `Iterator`",
+ None,
"this is more succinctly expressed by calling `.find(!p)` instead",
);
}
}
/// lint use of `filter().map()` for `Iterators`
-fn lint_filter_map<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_filter_map<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_filter_args: &'tcx [hir::Expr<'_>],
_map_args: &'tcx [hir::Expr<'_>],
if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter(p).map(q)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
- span_lint_and_help(cx, FILTER_MAP, expr.span, msg, hint);
+ span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
}
}
/// lint use of `filter_map().next()` for `Iterators`
-fn lint_filter_map_next<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- expr: &'tcx hir::Expr<'_>,
- filter_args: &'tcx [hir::Expr<'_>],
-) {
+fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
`.find_map(p)` instead.";
FILTER_MAP_NEXT,
expr.span,
msg,
- expr.span,
+ None,
&format!("replace `filter_map({0}).next()` with `find_map({0})`", filter_snippet),
);
} else {
}
/// lint use of `find().map()` for `Iterators`
-fn lint_find_map<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_find_map<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_find_args: &'tcx [hir::Expr<'_>],
map_args: &'tcx [hir::Expr<'_>],
if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
let msg = "called `find(p).map(q)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
- span_lint_and_help(cx, FIND_MAP, expr.span, msg, hint);
+ span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint);
}
}
/// lint use of `filter_map().map()` for `Iterators`
-fn lint_filter_map_map<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_filter_map_map<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_filter_args: &'tcx [hir::Expr<'_>],
_map_args: &'tcx [hir::Expr<'_>],
if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter_map(p).map(q)` on an `Iterator`";
let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
- span_lint_and_help(cx, FILTER_MAP, expr.span, msg, hint);
+ span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
}
}
/// lint use of `filter().flat_map()` for `Iterators`
-fn lint_filter_flat_map<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_filter_flat_map<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_filter_args: &'tcx [hir::Expr<'_>],
_map_args: &'tcx [hir::Expr<'_>],
let msg = "called `filter(p).flat_map(q)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
and filtering by returning `iter::empty()`";
- span_lint_and_help(cx, FILTER_MAP, expr.span, msg, hint);
+ span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
}
}
/// lint use of `filter_map().flat_map()` for `Iterators`
-fn lint_filter_map_flat_map<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_filter_map_flat_map<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
_filter_args: &'tcx [hir::Expr<'_>],
_map_args: &'tcx [hir::Expr<'_>],
let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
and filtering by returning `iter::empty()`";
- span_lint_and_help(cx, FILTER_MAP, expr.span, msg, hint);
+ span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
}
}
/// lint use of `flat_map` for `Iterators` where `flatten` would be sufficient
-fn lint_flat_map_identity<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_flat_map_identity<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
flat_map_args: &'tcx [hir::Expr<'_>],
flat_map_span: Span,
}
/// lint searching an Iterator followed by `is_some()`
-fn lint_search_is_some<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_search_is_some<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
search_method: &str,
search_args: &'tcx [hir::Expr<'_>],
}
/// Checks for the `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
-fn lint_binary_expr_with_method_call(cx: &LateContext<'_, '_>, info: &mut BinaryExprInfo<'_>) {
+fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExprInfo<'_>) {
macro_rules! lint_with_both_lhs_and_rhs {
($func:ident, $cx:expr, $info:ident) => {
if !$func($cx, $info) {
/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
fn lint_chars_cmp(
- cx: &LateContext<'_, '_>,
+ cx: &LateContext<'_>,
info: &BinaryExprInfo<'_>,
chain_methods: &[&str],
lint: &'static Lint,
if segment.ident.name == sym!(Some);
then {
let mut applicability = Applicability::MachineApplicable;
- let self_ty = walk_ptrs_ty(cx.tables.expr_ty_adjusted(&args[0][0]));
+ let self_ty = walk_ptrs_ty(cx.tables().expr_ty_adjusted(&args[0][0]));
if self_ty.kind != ty::Str {
return false;
}
/// Checks for the `CHARS_NEXT_CMP` lint.
-fn lint_chars_next_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
+fn lint_chars_next_cmp<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
lint_chars_cmp(cx, info, &["chars", "next"], CHARS_NEXT_CMP, "starts_with")
}
/// Checks for the `CHARS_LAST_CMP` lint.
-fn lint_chars_last_cmp<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
+fn lint_chars_last_cmp<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
if lint_chars_cmp(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
true
} else {
}
/// 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>,
+fn lint_chars_cmp_with_unwrap<'tcx>(
+ cx: &LateContext<'tcx>,
info: &BinaryExprInfo<'_>,
chain_methods: &[&str],
lint: &'static Lint,
}
/// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
-fn lint_chars_next_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
+fn lint_chars_next_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
lint_chars_cmp_with_unwrap(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
}
/// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
-fn lint_chars_last_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
+fn lint_chars_last_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
if lint_chars_cmp_with_unwrap(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
true
} else {
}
/// lint for length-1 `str`s for methods in `PATTERN_METHODS`
-fn lint_single_char_pattern<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
- _expr: &'tcx hir::Expr<'_>,
- arg: &'tcx hir::Expr<'_>,
-) {
+fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
if_chain! {
if let hir::ExprKind::Lit(lit) = &arg.kind;
if let ast::LitKind::Str(r, style) = lit.node;
}
/// Checks for the `USELESS_ASREF` lint.
-fn lint_asref(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
+fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
// when we get here, we've already checked that the call name is "as_ref" or "as_mut"
// check if the call is to the actual `AsRef` or `AsMut` trait
if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
// check if the type after `as_ref` or `as_mut` is the same as before
let recvr = &as_ref_args[0];
- let rcv_ty = cx.tables.expr_ty(recvr);
- let res_ty = cx.tables.expr_ty(expr);
+ let rcv_ty = cx.tables().expr_ty(recvr);
+ let res_ty = cx.tables().expr_ty(expr);
let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
// allow the `as_ref` or `as_mut` if it is followed by another method call
if_chain! {
if let Some(parent) = get_parent_expr(cx, expr);
- if let hir::ExprKind::MethodCall(_, ref span, _) = parent.kind;
+ if let hir::ExprKind::MethodCall(_, ref span, _, _) = parent.kind;
if span != &expr.span;
then {
return;
}
}
-fn ty_has_iter_method(cx: &LateContext<'_, '_>, self_ref_ty: Ty<'_>) -> Option<(&'static str, &'static str)> {
+fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(&'static str, &'static str)> {
has_iter_method(cx, self_ref_ty).map(|ty_name| {
let mutbl = match self_ref_ty.kind {
ty::Ref(_, _, mutbl) => mutbl,
})
}
-fn lint_into_iter(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_>, method_span: Span) {
+fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_>, method_span: Span) {
if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
return;
}
}
/// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
-fn lint_maybe_uninit(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, outer: &hir::Expr<'_>) {
+fn lint_maybe_uninit(cx: &LateContext<'_>, expr: &hir::Expr<'_>, outer: &hir::Expr<'_>) {
if_chain! {
if let hir::ExprKind::Call(ref callee, ref args) = expr.kind;
if args.is_empty();
if let hir::ExprKind::Path(ref path) = callee.kind;
if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
- if !is_maybe_uninit_ty_valid(cx, cx.tables.expr_ty_adjusted(outer));
+ if !is_maybe_uninit_ty_valid(cx, cx.tables().expr_ty_adjusted(outer));
then {
span_lint(
cx,
}
}
-fn is_maybe_uninit_ty_valid(cx: &LateContext<'_, '_>, ty: Ty<'_>) -> bool {
+fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
match ty.kind {
ty::Array(ref component, _) => is_maybe_uninit_ty_valid(cx, component),
ty::Tuple(ref types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
- ty::Adt(ref adt, _) => {
- // needs to be a MaybeUninit
- match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT)
- },
+ ty::Adt(ref adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
_ => false,
}
}
-fn lint_suspicious_map(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
+fn lint_suspicious_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
span_lint_and_help(
cx,
SUSPICIOUS_MAP,
expr.span,
"this call to `map()` won't have an effect on the call to `count()`",
+ None,
"make sure you did not confuse `map` with `filter` or `for_each`",
);
}
/// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
-fn lint_option_as_ref_deref<'a, 'tcx>(
- cx: &LateContext<'a, 'tcx>,
+fn lint_option_as_ref_deref<'tcx>(
+ cx: &LateContext<'tcx>,
expr: &hir::Expr<'_>,
as_ref_args: &[hir::Expr<'_>],
map_args: &[hir::Expr<'_>],
is_mut: bool,
) {
- let option_ty = cx.tables.expr_ty(&as_ref_args[0]);
- if !match_type(cx, option_ty, &paths::OPTION) {
+ let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
+
+ let option_ty = cx.tables().expr_ty(&as_ref_args[0]);
+ if !is_type_diagnostic_item(cx, option_ty, sym!(option_type)) {
return;
}
hir::ExprKind::Closure(_, _, body_id, _, _) => {
let closure_body = cx.tcx.hir().body(body_id);
let closure_expr = remove_blocks(&closure_body.value);
- if_chain! {
- if let hir::ExprKind::MethodCall(_, _, args) = &closure_expr.kind;
- if args.len() == 1;
- if let hir::ExprKind::Path(qpath) = &args[0].kind;
- if let hir::def::Res::Local(local_id) = cx.tables.qpath_res(qpath, args[0].hir_id);
- if closure_body.params[0].pat.hir_id == local_id;
- let adj = cx.tables.expr_adjustments(&args[0]).iter().map(|x| &x.kind).collect::<Box<[_]>>();
- if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
- then {
- let method_did = cx.tables.type_dependent_def_id(closure_expr.hir_id).unwrap();
- deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
- } else {
- false
- }
+
+ match &closure_expr.kind {
+ hir::ExprKind::MethodCall(_, _, args, _) => {
+ if_chain! {
+ if args.len() == 1;
+ if let hir::ExprKind::Path(qpath) = &args[0].kind;
+ if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, args[0].hir_id);
+ if closure_body.params[0].pat.hir_id == local_id;
+ let adj = cx.tables().expr_adjustments(&args[0]).iter().map(|x| &x.kind).collect::<Box<[_]>>();
+ if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
+ then {
+ let method_did = cx.tables().type_dependent_def_id(closure_expr.hir_id).unwrap();
+ deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
+ } else {
+ false
+ }
+ }
+ },
+ hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => {
+ if_chain! {
+ if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner1) = inner.kind;
+ if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner2) = inner1.kind;
+ if let hir::ExprKind::Path(ref qpath) = inner2.kind;
+ if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, inner2.hir_id);
+ then {
+ closure_body.params[0].pat.hir_id == local_id
+ } else {
+ false
+ }
+ }
+ },
+ _ => false,
}
},
-
_ => false,
};
if is_deref {
let current_method = if is_mut {
- ".as_mut().map(DerefMut::deref_mut)"
+ format!(".as_mut().map({})", snippet(cx, map_args[1].span, ".."))
} else {
- ".as_ref().map(Deref::deref)"
+ format!(".as_ref().map({})", snippet(cx, map_args[1].span, ".."))
};
let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
let hint = format!("{}.{}()", snippet(cx, as_ref_args[0].span, ".."), method_hint);
let suggestion = format!("try using {} instead", method_hint);
let msg = format!(
- "called `{0}` (or with one of deref aliases) on an Option value. \
- This can be done more directly by calling `{1}` instead",
+ "called `{0}` on an Option value. This can be done more directly \
+ by calling `{1}` instead",
current_method, hint
);
span_lint_and_sugg(
}
/// Given a `Result<T, E>` type, return its error type (`E`).
-fn get_error_type<'a>(cx: &LateContext<'_, '_>, ty: Ty<'a>) -> Option<Ty<'a>> {
+fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
match ty.kind {
- ty::Adt(_, substs) if match_type(cx, ty, &paths::RESULT) => substs.types().nth(1),
+ ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym!(result_type)) => substs.types().nth(1),
_ => None,
}
}
/// This checks whether a given type is known to implement Debug.
-fn has_debug_impl<'a, 'b>(ty: Ty<'a>, cx: &LateContext<'b, 'a>) -> bool {
+fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
cx.tcx
.get_diagnostic_item(sym::debug_trait)
.map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
(Convention::StartsWith("to_"), &[SelfKind::Ref]),
];
+const FN_HEADER: hir::FnHeader = hir::FnHeader {
+ unsafety: hir::Unsafety::Normal,
+ constness: hir::Constness::NotConst,
+ asyncness: hir::IsAsync::NotAsync,
+ abi: rustc_target::spec::abi::Abi::Rust,
+};
+
#[rustfmt::skip]
-const TRAIT_METHODS: [(&str, usize, SelfKind, OutType, &str); 30] = [
- ("add", 2, SelfKind::Value, OutType::Any, "std::ops::Add"),
- ("as_mut", 1, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"),
- ("as_ref", 1, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"),
- ("bitand", 2, SelfKind::Value, OutType::Any, "std::ops::BitAnd"),
- ("bitor", 2, SelfKind::Value, OutType::Any, "std::ops::BitOr"),
- ("bitxor", 2, SelfKind::Value, OutType::Any, "std::ops::BitXor"),
- ("borrow", 1, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"),
- ("borrow_mut", 1, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"),
- ("clone", 1, SelfKind::Ref, OutType::Any, "std::clone::Clone"),
- ("cmp", 2, SelfKind::Ref, OutType::Any, "std::cmp::Ord"),
- ("default", 0, SelfKind::No, OutType::Any, "std::default::Default"),
- ("deref", 1, SelfKind::Ref, OutType::Ref, "std::ops::Deref"),
- ("deref_mut", 1, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"),
- ("div", 2, SelfKind::Value, OutType::Any, "std::ops::Div"),
- ("drop", 1, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"),
- ("eq", 2, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"),
- ("from_iter", 1, SelfKind::No, OutType::Any, "std::iter::FromIterator"),
- ("from_str", 1, SelfKind::No, OutType::Any, "std::str::FromStr"),
- ("hash", 2, SelfKind::Ref, OutType::Unit, "std::hash::Hash"),
- ("index", 2, SelfKind::Ref, OutType::Ref, "std::ops::Index"),
- ("index_mut", 2, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"),
- ("into_iter", 1, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"),
- ("mul", 2, SelfKind::Value, OutType::Any, "std::ops::Mul"),
- ("neg", 1, SelfKind::Value, OutType::Any, "std::ops::Neg"),
- ("next", 1, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"),
- ("not", 1, SelfKind::Value, OutType::Any, "std::ops::Not"),
- ("rem", 2, SelfKind::Value, OutType::Any, "std::ops::Rem"),
- ("shl", 2, SelfKind::Value, OutType::Any, "std::ops::Shl"),
- ("shr", 2, SelfKind::Value, OutType::Any, "std::ops::Shr"),
- ("sub", 2, SelfKind::Value, OutType::Any, "std::ops::Sub"),
+const TRAIT_METHODS: [(&str, usize, &hir::FnHeader, SelfKind, OutType, &str); 30] = [
+ ("add", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Add"),
+ ("as_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"),
+ ("as_ref", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"),
+ ("bitand", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitAnd"),
+ ("bitor", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitOr"),
+ ("bitxor", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitXor"),
+ ("borrow", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"),
+ ("borrow_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"),
+ ("clone", 1, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::clone::Clone"),
+ ("cmp", 2, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::cmp::Ord"),
+ ("default", 0, &FN_HEADER, SelfKind::No, OutType::Any, "std::default::Default"),
+ ("deref", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::ops::Deref"),
+ ("deref_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"),
+ ("div", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Div"),
+ ("drop", 1, &FN_HEADER, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"),
+ ("eq", 2, &FN_HEADER, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"),
+ ("from_iter", 1, &FN_HEADER, SelfKind::No, OutType::Any, "std::iter::FromIterator"),
+ ("from_str", 1, &FN_HEADER, SelfKind::No, OutType::Any, "std::str::FromStr"),
+ ("hash", 2, &FN_HEADER, SelfKind::Ref, OutType::Unit, "std::hash::Hash"),
+ ("index", 2, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::ops::Index"),
+ ("index_mut", 2, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"),
+ ("into_iter", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"),
+ ("mul", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Mul"),
+ ("neg", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Neg"),
+ ("next", 1, &FN_HEADER, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"),
+ ("not", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Not"),
+ ("rem", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Rem"),
+ ("shl", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Shl"),
+ ("shr", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Shr"),
+ ("sub", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Sub"),
];
#[rustfmt::skip]
}
impl SelfKind {
- fn matches<'a>(self, cx: &LateContext<'_, 'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
- fn matches_value(parent_ty: Ty<'_>, ty: Ty<'_>) -> bool {
+ fn matches<'a>(self, cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+ fn matches_value<'a>(cx: &LateContext<'a>, parent_ty: Ty<'_>, ty: Ty<'_>) -> bool {
if ty == parent_ty {
true
} else if ty.is_box() {
ty.boxed_ty() == parent_ty
- } else if ty.is_rc() || ty.is_arc() {
+ } else if is_type_diagnostic_item(cx, ty, sym::Rc) || is_type_diagnostic_item(cx, ty, sym::Arc) {
if let ty::Adt(_, substs) = ty.kind {
substs.types().next().map_or(false, |t| t == parent_ty)
} else {
}
}
- fn matches_ref<'a>(
- cx: &LateContext<'_, 'a>,
- mutability: hir::Mutability,
- parent_ty: Ty<'a>,
- ty: Ty<'a>,
- ) -> bool {
+ fn matches_ref<'a>(cx: &LateContext<'a>, mutability: hir::Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
if let ty::Ref(_, t, m) = ty.kind {
return m == mutability && t == parent_ty;
}
}
match self {
- Self::Value => matches_value(parent_ty, ty),
+ Self::Value => matches_value(cx, parent_ty, ty),
Self::Ref => matches_ref(cx, hir::Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty),
Self::RefMut => matches_ref(cx, hir::Mutability::Mut, parent_ty, ty),
Self::No => ty != parent_ty,
}
impl OutType {
- fn matches(self, cx: &LateContext<'_, '_>, ty: &hir::FnRetTy<'_>) -> bool {
+ fn matches(self, cx: &LateContext<'_>, ty: &hir::FnRetTy<'_>) -> bool {
let is_unit = |ty: &hir::Ty<'_>| SpanlessEq::new(cx).eq_ty_kind(&ty.kind, &hir::TyKind::Tup(&[]));
match (self, ty) {
(Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
visitor.found
}
-fn check_pointer_offset(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+fn check_pointer_offset(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
if_chain! {
if args.len() == 2;
- if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.tables.expr_ty(&args[0]).kind;
+ if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.tables().expr_ty(&args[0]).kind;
if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
if layout.is_zst();
then {
}
}
-fn lint_filetype_is_file(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
- let ty = cx.tables.expr_ty(&args[0]);
+fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+ let ty = cx.tables().expr_ty(&args[0]);
if !match_type(cx, ty, &paths::FILE_TYPE) {
return;
}
let lint_msg = format!("`{}FileType::is_file()` only {} regular files", lint_unary, verb);
let help_msg = format!("use `{}FileType::is_dir()` instead", help_unary);
- span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, &help_msg);
+ span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, None, &help_msg);
+}
+
+fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
+ expected.constness == actual.constness
+ && expected.unsafety == actual.unsafety
+ && expected.asyncness == actual.asyncness
}
projects / rust.git / blobdiff