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_span::sym;
  14
  15 use super::MANUAL_UNWRAP_OR;
  16
  17 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
  18     let ty = cx.typeck_results().expr_ty(scrutinee);
  19     if_chain! {
  20         if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
  21             Some("Option")
  22         } else if is_type_diagnostic_item(cx, ty, sym::Result) {
  23             Some("Result")
  24         } else {
  25             None
  26         };
  27         if let Some(or_arm) = applicable_or_arm(cx, arms);
  28         if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
  29         if let Some(indent) = indent_of(cx, expr.span);
  30         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
  31         then {
  32             let reindented_or_body =
  33                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
  34
  35             let mut app = Applicability::MachineApplicable;
  36             let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
  37             span_lint_and_sugg(
  38                 cx,
  39                 MANUAL_UNWRAP_OR, expr.span,
  40                 &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
  41                 "replace with",
  42                 format!(
  43                     "{suggestion}.unwrap_or({reindented_or_body})",
  44                 ),
  45                 app,
  46             );
  47         }
  48     }
  49 }
  50
  51 fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
  52     if_chain! {
  53         if arms.len() == 2;
  54         if arms.iter().all(|arm| arm.guard.is_none());
  55         if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
  56             match arm.pat.kind {
  57                 PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
  58                 PatKind::TupleStruct(ref qpath, [pat], _) =>
  59                     matches!(pat.kind, PatKind::Wild)
  60                         && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr),
  61                 _ => false,
  62             }
  63         });
  64         let unwrap_arm = &arms[1 - idx];
  65         if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
  66         if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, unwrap_arm.pat.hir_id);
  67         if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
  68         if cx.tcx.lang_items().option_some_variant() == Some(variant_id)
  69             || cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
  70         if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
  71         if path_to_local_id(unwrap_arm.body, binding_hir_id);
  72         if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
  73         if !contains_return_break_continue_macro(or_arm.body);
  74         then {
  75             Some(or_arm)
  76         } else {
  77             None
  78         }
  79     }
  80 }