src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs

   1 use clippy_utils::consts::constant_simple;
   2 use clippy_utils::diagnostics::span_lint_and_sugg;
   3 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
   4 use clippy_utils::ty::is_type_diagnostic_item;
   5 use clippy_utils::usage::contains_return_break_continue_macro;
   6 use clippy_utils::{is_res_lang_ctor, path_to_local_id, sugg};
   7 use if_chain::if_chain;
   8 use rustc_errors::Applicability;
   9 use rustc_hir::def::{DefKind, Res};
  10 use rustc_hir::LangItem::{OptionNone, ResultErr};
  11 use rustc_hir::{Arm, Expr, PatKind};
  12 use rustc_lint::LateContext;
  13 use rustc_middle::ty::DefIdTree;
  14 use rustc_span::sym;
  15
  16 use super::MANUAL_UNWRAP_OR;
  17
  18 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
  19     let ty = cx.typeck_results().expr_ty(scrutinee);
  20     if_chain! {
  21         if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
  22             Some("Option")
  23         } else if is_type_diagnostic_item(cx, ty, sym::Result) {
  24             Some("Result")
  25         } else {
  26             None
  27         };
  28         if let Some(or_arm) = applicable_or_arm(cx, arms);
  29         if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
  30         if let Some(indent) = indent_of(cx, expr.span);
  31         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
  32         then {
  33             let reindented_or_body =
  34                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
  35
  36             let suggestion = if scrutinee.span.from_expansion() {
  37                     // we don't want parentheses around macro, e.g. `(some_macro!()).unwrap_or(0)`
  38                     sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
  39                 }
  40                 else {
  41                     sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
  42                 };
  43
  44             span_lint_and_sugg(
  45                 cx,
  46                 MANUAL_UNWRAP_OR, expr.span,
  47                 &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
  48                 "replace with",
  49                 format!(
  50                     "{suggestion}.unwrap_or({reindented_or_body})",
  51                 ),
  52                 Applicability::MachineApplicable,
  53             );
  54         }
  55     }
  56 }
  57
  58 fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
  59     if_chain! {
  60         if arms.len() == 2;
  61         if arms.iter().all(|arm| arm.guard.is_none());
  62         if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
  63             match arm.pat.kind {
  64                 PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
  65                 PatKind::TupleStruct(ref qpath, [pat], _) =>
  66                     matches!(pat.kind, PatKind::Wild)
  67                         && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr),
  68                 _ => false,
  69             }
  70         });
  71         let unwrap_arm = &arms[1 - idx];
  72         if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
  73         if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, unwrap_arm.pat.hir_id);
  74         if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
  75         if cx.tcx.lang_items().option_some_variant() == Some(variant_id)
  76             || cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
  77         if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
  78         if path_to_local_id(unwrap_arm.body, binding_hir_id);
  79         if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
  80         if !contains_return_break_continue_macro(or_arm.body);
  81         then {
  82             Some(or_arm)
  83         } else {
  84             None
  85         }
  86     }
  87 }