1 use clippy_utils::diagnostics::span_lint_and_sugg;
2 use clippy_utils::source::snippet_with_applicability;
3 use clippy_utils::ty::is_type_diagnostic_item;
4 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
5 use if_chain::if_chain;
6 use rustc_errors::Applicability;
7 use rustc_hir::LangItem::ResultErr;
8 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
9 use rustc_lint::LateContext;
10 use rustc_middle::ty::{self, Ty};
11 use rustc_span::{hygiene, sym};
15 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutinee: &'tcx Expr<'_>) {
16 // Looks for a structure like this:
17 // match ::std::ops::Try::into_result(Err(5)) {
18 // ::std::result::Result::Err(err) =>
19 // #[allow(unreachable_code)]
20 // return ::std::ops::Try::from_error(::std::convert::From::from(err)),
21 // ::std::result::Result::Ok(val) =>
22 // #[allow(unreachable_code)]
26 if let ExprKind::Call(match_fun, [try_arg, ..]) = scrutinee.kind;
27 if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
28 if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
29 if let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind;
30 if is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr);
31 if let Some(return_ty) = find_return_type(cx, &expr.kind);
37 if let Some(ty) = result_error_type(cx, return_ty) {
41 } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
42 prefix = "Poll::Ready(Err(";
45 } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
46 prefix = "Poll::Ready(Some(Err(";
53 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
54 let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
55 let mut applicability = Applicability::MachineApplicable;
56 let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
57 let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
62 let suggestion = if err_ty == expr_err_ty {
63 format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
65 format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
72 "returning an `Err(_)` with the `?` operator",
81 /// Finds function return type by examining return expressions in match arms.
82 fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
83 if let ExprKind::Match(_, arms, MatchSource::TryDesugar) = expr {
84 for arm in arms.iter() {
85 if let ExprKind::Ret(Some(ret)) = arm.body.kind {
86 return Some(cx.typeck_results().expr_ty(ret));
93 /// Extracts the error type from Result<T, E>.
94 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
96 if let ty::Adt(_, subst) = ty.kind();
97 if is_type_diagnostic_item(cx, ty, sym::Result);
99 Some(subst.type_at(1))
106 /// Extracts the error type from Poll<Result<T, E>>.
107 fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
109 if let ty::Adt(def, subst) = ty.kind();
110 if cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did());
111 let ready_ty = subst.type_at(0);
113 if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
114 if cx.tcx.is_diagnostic_item(sym::Result, ready_def.did());
116 Some(ready_subst.type_at(1))
123 /// Extracts the error type from Poll<Option<Result<T, E>>>.
124 fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
126 if let ty::Adt(def, subst) = ty.kind();
127 if cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did());
128 let ready_ty = subst.type_at(0);
130 if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
131 if cx.tcx.is_diagnostic_item(sym::Option, ready_def.did());
132 let some_ty = ready_subst.type_at(0);
134 if let ty::Adt(some_def, some_subst) = some_ty.kind();
135 if cx.tcx.is_diagnostic_item(sym::Result, some_def.did());
137 Some(some_subst.type_at(1))