1 use crate::utils::{in_macro_or_desugar, match_qpath, paths, snippet, span_lint_and_sugg};
2 use if_chain::if_chain;
4 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
6 use rustc::{declare_lint_pass, declare_tool_lint};
7 use rustc_errors::Applicability;
8 use syntax::source_map::Span;
10 declare_clippy_lint! {
11 /// **What it does:** Checks for usages of `Err(x)?`.
13 /// **Why is this bad?** The `?` operator is designed to allow calls that
14 /// can fail to be easily chained. For example, `foo()?.bar()` or
15 /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
16 /// always return), it is more clear to write `return Err(x)`.
18 /// **Known problems:** None.
22 /// fn foo(fail: bool) -> Result<i32, String> {
32 /// fn foo(fail: bool) -> Result<i32, String> {
34 /// return Err("failed".into());
41 "return errors explicitly rather than hiding them behind a `?`"
44 declare_lint_pass!(TryErr => [TRY_ERR]);
46 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TryErr {
47 fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
48 // Looks for a structure like this:
49 // match ::std::ops::Try::into_result(Err(5)) {
50 // ::std::result::Result::Err(err) =>
51 // #[allow(unreachable_code)]
52 // return ::std::ops::Try::from_error(::std::convert::From::from(err)),
53 // ::std::result::Result::Ok(val) =>
54 // #[allow(unreachable_code)]
58 if let ExprKind::Match(ref match_arg, _, MatchSource::TryDesugar) = expr.node;
59 if let ExprKind::Call(ref match_fun, ref try_args) = match_arg.node;
60 if let ExprKind::Path(ref match_fun_path) = match_fun.node;
61 if match_qpath(match_fun_path, &paths::TRY_INTO_RESULT);
62 if let Some(ref try_arg) = try_args.get(0);
63 if let ExprKind::Call(ref err_fun, ref err_args) = try_arg.node;
64 if let Some(ref err_arg) = err_args.get(0);
65 if let ExprKind::Path(ref err_fun_path) = err_fun.node;
66 if match_qpath(err_fun_path, &paths::RESULT_ERR);
67 if let Some(return_type) = find_err_return_type(cx, &expr.node);
70 let err_type = cx.tables.expr_ty(err_arg);
71 let span = if in_macro_or_desugar(err_arg.span) {
72 span_to_outer_expn(err_arg.span)
76 let suggestion = if err_type == return_type {
77 format!("return Err({})", snippet(cx, span, "_"))
79 format!("return Err({}.into())", snippet(cx, span, "_"))
86 "returning an `Err(_)` with the `?` operator",
89 Applicability::MachineApplicable
96 fn span_to_outer_expn(span: Span) -> Span {
98 while let Some(expr) = span.ctxt().outer_expn_info() {
99 span = expr.call_site;
104 // In order to determine whether to suggest `.into()` or not, we need to find the error type the
105 // function returns. To do that, we look for the From::from call (see tree above), and capture
107 fn find_err_return_type<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx ExprKind) -> Option<Ty<'tcx>> {
108 if let ExprKind::Match(_, ref arms, MatchSource::TryDesugar) = expr {
109 arms.iter().find_map(|ty| find_err_return_type_arm(cx, ty))
115 // Check for From::from in one of the match arms.
116 fn find_err_return_type_arm<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arm: &'tcx Arm) -> Option<Ty<'tcx>> {
118 if let ExprKind::Ret(Some(ref err_ret)) = arm.body.node;
119 if let ExprKind::Call(ref from_error_path, ref from_error_args) = err_ret.node;
120 if let ExprKind::Path(ref from_error_fn) = from_error_path.node;
121 if match_qpath(from_error_fn, &paths::TRY_FROM_ERROR);
122 if let Some(from_error_arg) = from_error_args.get(0);
124 Some(cx.tables.expr_ty(from_error_arg))