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_lang_ctor, path_to_local_id, sugg};
   7 use if_chain::if_chain;
   8 use rustc_errors::Applicability;
   9 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
  10 use rustc_hir::{Arm, Expr, PatKind};
  11 use rustc_lint::LateContext;
  12 use rustc_span::sym;
  13
  14 use super::MANUAL_UNWRAP_OR;
  15
  16 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
  17     let ty = cx.typeck_results().expr_ty(scrutinee);
  18     if_chain! {
  19         if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
  20             Some("Option")
  21         } else if is_type_diagnostic_item(cx, ty, sym::Result) {
  22             Some("Result")
  23         } else {
  24             None
  25         };
  26         if let Some(or_arm) = applicable_or_arm(cx, arms);
  27         if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
  28         if let Some(indent) = indent_of(cx, expr.span);
  29         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
  30         then {
  31             let reindented_or_body =
  32                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
  33
  34             let suggestion = if scrutinee.span.from_expansion() {
  35                     // we don't want parentheses around macro, e.g. `(some_macro!()).unwrap_or(0)`
  36                     sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
  37                 }
  38                 else {
  39                     sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
  40                 };
  41
  42             span_lint_and_sugg(
  43                 cx,
  44                 MANUAL_UNWRAP_OR, expr.span,
  45                 &format!("this pattern reimplements `{}::unwrap_or`", ty_name),
  46                 "replace with",
  47                 format!(
  48                     "{}.unwrap_or({})",
  49                     suggestion,
  50                     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_lang_ctor(cx, qpath, OptionNone),
  65                 PatKind::TupleStruct(ref qpath, [pat], _) =>
  66                     matches!(pat.kind, PatKind::Wild) && is_lang_ctor(cx, qpath, ResultErr),
  67                 _ => false,
  68             }
  69         });
  70         let unwrap_arm = &arms[1 - idx];
  71         if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
  72         if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
  73         if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
  74         if path_to_local_id(unwrap_arm.body, binding_hir_id);
  75         if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
  76         if !contains_return_break_continue_macro(or_arm.body);
  77         then {
  78             Some(or_arm)
  79         } else {
  80             None
  81         }
  82     }
  83 }