rust-clippy/clippy_lints/src/methods/unnecessary_lazy_eval.rs

use crate::utils::{match_qpath, span_lint_and_sugg, snippet, is_type_diagnostic_item};
use if_chain::if_chain;
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_lint::LateContext;

use super::UNNECESSARY_LAZY_EVALUATION;

/// 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>(
    cx: &LateContext<'tcx>,
    expr: &'tcx hir::Expr<'_>,
    args: &'tcx [hir::Expr<'_>],
    allow_variant_calls: bool,
    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));

    if !is_option && !is_result {
        return;
    }

    // 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
                }
            }
        })
    }

    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)
                } 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))
                } 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,
        }
    }

    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,
            );
        }
    }
}