-use crate::utils::{is_type_diagnostic_item, match_qpath, snippet, span_lint_and_sugg};
-use if_chain::if_chain;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{eager_or_lazy, usage};
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_lint::LateContext;
+use rustc_span::sym;
-use super::UNNECESSARY_LAZY_EVALUATION;
+use super::UNNECESSARY_LAZY_EVALUATIONS;
/// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
/// replaced with `<fn>(return value of simple closure)`
-pub(super) fn lint<'tcx>(
+pub(super) fn check<'tcx>(
cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
- args: &'tcx [hir::Expr<'_>],
- allow_variant_calls: bool,
+ recv: &'tcx hir::Expr<'_>,
+ arg: &'tcx hir::Expr<'_>,
simplify_using: &str,
) {
- let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
- let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
+ let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type);
+ let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
- if !is_option && !is_result {
- return;
- }
+ if is_option || is_result {
+ if let hir::ExprKind::Closure(_, _, eid, _, _) = arg.kind {
+ let body = cx.tcx.hir().body(eid);
+ let body_expr = &body.value;
- // Return true if the expression is an accessor of any of the arguments
- fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
- params.iter().any(|arg| {
- if_chain! {
- if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
- if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
- if let [p, ..] = path.segments;
- then {
- ident.name == p.ident.name
- } else {
- false
- }
+ if usage::BindingUsageFinder::are_params_used(cx, body) {
+ return;
}
- })
- }
-
- fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
- paths.iter().any(|candidate| match_qpath(path, candidate))
- }
-
- fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
- match expr.kind {
- // Closures returning literals can be unconditionally simplified
- hir::ExprKind::Lit(_) => true,
- hir::ExprKind::Index(ref object, ref index) => {
- // arguments are not being indexed into
- if !expr_uses_argument(object, params) {
- // arguments are not used as index
- !expr_uses_argument(index, params)
+ if eager_or_lazy::is_eagerness_candidate(cx, body_expr) {
+ let msg = if is_option {
+ "unnecessary closure used to substitute value for `Option::None`"
} else {
- false
- }
- },
-
- // Reading fields can be simplified if the object is not an argument of the closure
- hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
-
- // Paths can be simplified if the root is not the argument, this also covers None
- hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
-
- // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
- hir::ExprKind::Call(ref func, ref args) => if_chain! {
- if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
- if let hir::ExprKind::Path(ref path) = func.kind;
- if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
- then {
- // Recursively check all arguments
- args.iter().all(|arg| can_simplify(arg, params, variant_calls))
+ "unnecessary closure used to substitute value for `Result::Err`"
+ };
+ let applicability = if body
+ .params
+ .iter()
+ // bindings are checked to be unused above
+ .all(|param| matches!(param.pat.kind, hir::PatKind::Binding(..) | hir::PatKind::Wild))
+ {
+ Applicability::MachineApplicable
} else {
- false
- }
- },
-
- // For anything more complex than the above, a closure is probably the right solution,
- // or the case is handled by an other lint
- _ => false,
- }
- }
+ // replacing the lambda may break type inference
+ Applicability::MaybeIncorrect
+ };
- if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
- let body = cx.tcx.hir().body(eid);
- let ex = &body.value;
- let params = &body.params;
-
- if can_simplify(ex, params, allow_variant_calls) {
- let msg = if is_option {
- "unnecessary closure used to substitute value for `Option::None`"
- } else {
- "unnecessary closure used to substitute value for `Result::Err`"
- };
-
- span_lint_and_sugg(
- cx,
- UNNECESSARY_LAZY_EVALUATION,
- expr.span,
- msg,
- &format!("Use `{}` instead", simplify_using),
- format!(
- "{0}.{1}({2})",
- snippet(cx, args[0].span, ".."),
- simplify_using,
- snippet(cx, ex.span, ".."),
- ),
- Applicability::MachineApplicable,
- );
+ span_lint_and_sugg(
+ cx,
+ UNNECESSARY_LAZY_EVALUATIONS,
+ expr.span,
+ msg,
+ &format!("use `{}` instead", simplify_using),
+ format!(
+ "{0}.{1}({2})",
+ snippet(cx, recv.span, ".."),
+ simplify_using,
+ snippet(cx, body_expr.span, ".."),
+ ),
+ applicability,
+ );
+ }
}
}
}
projects / rust.git / blobdiff