clippy_lints/src/try_err.rs

   1 use crate::utils::{
   2     is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
   3     span_lint_and_sugg,
   4 };
   5 use if_chain::if_chain;
   6 use rustc_errors::Applicability;
   7 use rustc_hir::{Expr, ExprKind, MatchSource};
   8 use rustc_lint::{LateContext, LateLintPass};
   9 use rustc_middle::lint::in_external_macro;
  10 use rustc_middle::ty::{self, Ty};
  11 use rustc_session::{declare_lint_pass, declare_tool_lint};
  12
  13 declare_clippy_lint! {
  14     /// **What it does:** Checks for usages of `Err(x)?`.
  15     ///
  16     /// **Why is this bad?** The `?` operator is designed to allow calls that
  17     /// can fail to be easily chained. For example, `foo()?.bar()` or
  18     /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
  19     /// always return), it is more clear to write `return Err(x)`.
  20     ///
  21     /// **Known problems:** None.
  22     ///
  23     /// **Example:**
  24     /// ```rust
  25     /// fn foo(fail: bool) -> Result<i32, String> {
  26     ///     if fail {
  27     ///       Err("failed")?;
  28     ///     }
  29     ///     Ok(0)
  30     /// }
  31     /// ```
  32     /// Could be written:
  33     ///
  34     /// ```rust
  35     /// fn foo(fail: bool) -> Result<i32, String> {
  36     ///     if fail {
  37     ///       return Err("failed".into());
  38     ///     }
  39     ///     Ok(0)
  40     /// }
  41     /// ```
  42     pub TRY_ERR,
  43     style,
  44     "return errors explicitly rather than hiding them behind a `?`"
  45 }
  46
  47 declare_lint_pass!(TryErr => [TRY_ERR]);
  48
  49 impl<'tcx> LateLintPass<'tcx> for TryErr {
  50     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  51         // Looks for a structure like this:
  52         // match ::std::ops::Try::into_result(Err(5)) {
  53         //     ::std::result::Result::Err(err) =>
  54         //         #[allow(unreachable_code)]
  55         //         return ::std::ops::Try::from_error(::std::convert::From::from(err)),
  56         //     ::std::result::Result::Ok(val) =>
  57         //         #[allow(unreachable_code)]
  58         //         val,
  59         // };
  60         if_chain! {
  61             if !in_external_macro(cx.tcx.sess, expr.span);
  62             if let ExprKind::Match(ref match_arg, _, MatchSource::TryDesugar) = expr.kind;
  63             if let ExprKind::Call(ref match_fun, ref try_args) = match_arg.kind;
  64             if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
  65             if match_qpath(match_fun_path, &paths::TRY_INTO_RESULT);
  66             if let Some(ref try_arg) = try_args.get(0);
  67             if let ExprKind::Call(ref err_fun, ref err_args) = try_arg.kind;
  68             if let Some(ref err_arg) = err_args.get(0);
  69             if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
  70             if match_qpath(err_fun_path, &paths::RESULT_ERR);
  71             if let Some(return_ty) = find_return_type(cx, &expr.kind);
  72             then {
  73                 let prefix;
  74                 let suffix;
  75                 let err_ty;
  76
  77                 if let Some(ty) = result_error_type(cx, return_ty) {
  78                     prefix = "Err(";
  79                     suffix = ")";
  80                     err_ty = ty;
  81                 } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
  82                     prefix = "Poll::Ready(Err(";
  83                     suffix = "))";
  84                     err_ty = ty;
  85                 } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
  86                     prefix = "Poll::Ready(Some(Err(";
  87                     suffix = ")))";
  88                     err_ty = ty;
  89                 } else {
  90                     return;
  91                 };
  92
  93                 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
  94
  95                 let origin_snippet = if err_arg.span.from_expansion() {
  96                     snippet_with_macro_callsite(cx, err_arg.span, "_")
  97                 } else {
  98                     snippet(cx, err_arg.span, "_")
  99                 };
 100                 let suggestion = if err_ty == expr_err_ty {
 101                     format!("return {}{}{}", prefix, origin_snippet, suffix)
 102                 } else {
 103                     format!("return {}{}.into(){}", prefix, origin_snippet, suffix)
 104                 };
 105
 106                 span_lint_and_sugg(
 107                     cx,
 108                     TRY_ERR,
 109                     expr.span,
 110                     "returning an `Err(_)` with the `?` operator",
 111                     "try this",
 112                     suggestion,
 113                     Applicability::MachineApplicable
 114                 );
 115             }
 116         }
 117     }
 118 }
 119
 120 /// Finds function return type by examining return expressions in match arms.
 121 fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
 122     if let ExprKind::Match(_, ref arms, MatchSource::TryDesugar) = expr {
 123         for arm in arms.iter() {
 124             if let ExprKind::Ret(Some(ref ret)) = arm.body.kind {
 125                 return Some(cx.typeck_results().expr_ty(ret));
 126             }
 127         }
 128     }
 129     None
 130 }
 131
 132 /// Extracts the error type from Result<T, E>.
 133 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
 134     if_chain! {
 135         if let ty::Adt(_, subst) = ty.kind;
 136         if is_type_diagnostic_item(cx, ty, sym!(result_type));
 137         let err_ty = subst.type_at(1);
 138         then {
 139             Some(err_ty)
 140         } else {
 141             None
 142         }
 143     }
 144 }
 145
 146 /// Extracts the error type from Poll<Result<T, E>>.
 147 fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
 148     if_chain! {
 149         if let ty::Adt(def, subst) = ty.kind;
 150         if match_def_path(cx, def.did, &paths::POLL);
 151         let ready_ty = subst.type_at(0);
 152
 153         if let ty::Adt(ready_def, ready_subst) = ready_ty.kind;
 154         if cx.tcx.is_diagnostic_item(sym!(result_type), ready_def.did);
 155         let err_ty = ready_subst.type_at(1);
 156
 157         then {
 158             Some(err_ty)
 159         } else {
 160             None
 161         }
 162     }
 163 }
 164
 165 /// Extracts the error type from Poll<Option<Result<T, E>>>.
 166 fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
 167     if_chain! {
 168         if let ty::Adt(def, subst) = ty.kind;
 169         if match_def_path(cx, def.did, &paths::POLL);
 170         let ready_ty = subst.type_at(0);
 171
 172         if let ty::Adt(ready_def, ready_subst) = ready_ty.kind;
 173         if cx.tcx.is_diagnostic_item(sym!(option_type), ready_def.did);
 174         let some_ty = ready_subst.type_at(0);
 175
 176         if let ty::Adt(some_def, some_subst) = some_ty.kind;
 177         if cx.tcx.is_diagnostic_item(sym!(result_type), some_def.did);
 178         let err_ty = some_subst.type_at(1);
 179
 180         then {
 181             Some(err_ty)
 182         } else {
 183             None
 184         }
 185     }
 186 }