rust/clippy_lints/src/manual_unwrap_or_default.rs

use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::{Arm, Expr, ExprKind, HirId, LangItem, MatchSource, Pat, PatKind, QPath};
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::declare_lint_pass;
use rustc_span::sym;

use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::is_default_equivalent;
use clippy_utils::source::snippet_opt;
use clippy_utils::ty::implements_trait;

declare_clippy_lint! {
    /// ### What it does
    /// Checks if a `match` or `if let` expression can be simplified using
    /// `.unwrap_or_default()`.
    ///
    /// ### Why is this bad?
    /// It can be done in one call with `.unwrap_or_default()`.
    ///
    /// ### Example
    /// ```no_run
    /// let x: Option<String> = Some(String::new());
    /// let y: String = match x {
    ///     Some(v) => v,
    ///     None => String::new(),
    /// };
    ///
    /// let x: Option<Vec<String>> = Some(Vec::new());
    /// let y: Vec<String> = if let Some(v) = x {
    ///     v
    /// } else {
    ///     Vec::new()
    /// };
    /// ```
    /// Use instead:
    /// ```no_run
    /// let x: Option<String> = Some(String::new());
    /// let y: String = x.unwrap_or_default();
    ///
    /// let x: Option<Vec<String>> = Some(Vec::new());
    /// let y: Vec<String> = x.unwrap_or_default();
    /// ```
    #[clippy::version = "1.78.0"]
    pub MANUAL_UNWRAP_OR_DEFAULT,
    suspicious,
    "check if a `match` or `if let` can be simplified with `unwrap_or_default`"
}

declare_lint_pass!(ManualUnwrapOrDefault => [MANUAL_UNWRAP_OR_DEFAULT]);

fn get_some<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<HirId> {
    if let PatKind::TupleStruct(QPath::Resolved(_, path), &[pat], _) = pat.kind
        && let Some(def_id) = path.res.opt_def_id()
        // Since it comes from a pattern binding, we need to get the parent to actually match
        // against it.
        && let Some(def_id) = cx.tcx.opt_parent(def_id)
        && cx.tcx.lang_items().get(LangItem::OptionSome) == Some(def_id)
    {
        let mut bindings = Vec::new();
        pat.each_binding(|_, id, _, _| bindings.push(id));
        if let &[id] = bindings.as_slice() {
            Some(id)
        } else {
            None
        }
    } else {
        None
    }
}

fn get_none<'tcx>(cx: &LateContext<'tcx>, arm: &Arm<'tcx>) -> Option<&'tcx Expr<'tcx>> {
    if let PatKind::Path(QPath::Resolved(_, path)) = arm.pat.kind
        && let Some(def_id) = path.res.opt_def_id()
        // Since it comes from a pattern binding, we need to get the parent to actually match
        // against it.
        && let Some(def_id) = cx.tcx.opt_parent(def_id)
        && cx.tcx.lang_items().get(LangItem::OptionNone) == Some(def_id)
    {
        Some(arm.body)
    } else if let PatKind::Wild = arm.pat.kind {
        // We consider that the `Some` check will filter it out if it's not right.
        Some(arm.body)
    } else {
        None
    }
}

fn get_some_and_none_bodies<'tcx>(
    cx: &LateContext<'tcx>,
    arm1: &'tcx Arm<'tcx>,
    arm2: &'tcx Arm<'tcx>,
) -> Option<((&'tcx Expr<'tcx>, HirId), &'tcx Expr<'tcx>)> {
    if let Some(binding_id) = get_some(cx, arm1.pat)
        && let Some(body_none) = get_none(cx, arm2)
    {
        Some(((arm1.body, binding_id), body_none))
    } else if let Some(binding_id) = get_some(cx, arm2.pat)
        && let Some(body_none) = get_none(cx, arm1)
    {
        Some(((arm2.body, binding_id), body_none))
    } else {
        None
    }
}

fn handle_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
    let ExprKind::Match(match_expr, [arm1, arm2], MatchSource::Normal | MatchSource::ForLoopDesugar) = expr.kind else {
        return false;
    };
    // We don't want conditions on the arms to simplify things.
    if arm1.guard.is_none()
        && arm2.guard.is_none()
        // We check that the returned type implements the `Default` trait.
        && let match_ty = cx.typeck_results().expr_ty(expr)
        && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
        && implements_trait(cx, match_ty, default_trait_id, &[])
        // We now get the bodies for both the `Some` and `None` arms.
        && let Some(((body_some, binding_id), body_none)) = get_some_and_none_bodies(cx, arm1, arm2)
        // We check that the `Some(x) => x` doesn't do anything apart "returning" the value in `Some`.
        && let ExprKind::Path(QPath::Resolved(_, path)) = body_some.peel_blocks().kind
        && let Res::Local(local_id) = path.res
        && local_id == binding_id
        // We now check the `None` arm is calling a method equivalent to `Default::default`.
        && let body_none = body_none.peel_blocks()
        && is_default_equivalent(cx, body_none)
        && let Some(match_expr_snippet) = snippet_opt(cx, match_expr.span)
    {
        span_lint_and_sugg(
            cx,
            MANUAL_UNWRAP_OR_DEFAULT,
            expr.span,
            "match can be simplified with `.unwrap_or_default()`",
            "replace it with",
            format!("{match_expr_snippet}.unwrap_or_default()"),
            Applicability::MachineApplicable,
        );
    }
    true
}

fn handle_if_let<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
    if let ExprKind::If(cond, if_block, Some(else_expr)) = expr.kind
        && let ExprKind::Let(let_) = cond.kind
        && let ExprKind::Block(_, _) = else_expr.kind
        // We check that the returned type implements the `Default` trait.
        && let match_ty = cx.typeck_results().expr_ty(expr)
        && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
        && implements_trait(cx, match_ty, default_trait_id, &[])
        && let Some(binding_id) = get_some(cx, let_.pat)
        // We check that the `Some(x) => x` doesn't do anything apart "returning" the value in `Some`.
        && let ExprKind::Path(QPath::Resolved(_, path)) = if_block.peel_blocks().kind
        && let Res::Local(local_id) = path.res
        && local_id == binding_id
        // We now check the `None` arm is calling a method equivalent to `Default::default`.
        && let body_else = else_expr.peel_blocks()
        && is_default_equivalent(cx, body_else)
        && let Some(if_let_expr_snippet) = snippet_opt(cx, let_.init.span)
    {
        span_lint_and_sugg(
            cx,
            MANUAL_UNWRAP_OR_DEFAULT,
            expr.span,
            "if let can be simplified with `.unwrap_or_default()`",
            "replace it with",
            format!("{if_let_expr_snippet}.unwrap_or_default()"),
            Applicability::MachineApplicable,
        );
    }
}

impl<'tcx> LateLintPass<'tcx> for ManualUnwrapOrDefault {
    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
        if expr.span.from_expansion() {
            return;
        }
        if !handle_match(cx, expr) {
            handle_if_let(cx, expr);
        }
    }
}