1 use crate::utils::span_lint_and_help;
3 use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind};
4 use rustc_lint::{LateContext, LateLintPass};
5 use rustc_session::{declare_lint_pass, declare_tool_lint};
8 /// **What it does:** Checks for instances of `map_err(|_| Some::Enum)`
10 /// **Why is this bad?** This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
12 /// **Known problems:** None.
25 /// impl fmt::Display for Error {
26 /// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
28 /// Error::Indivisible => write!(f, "could not divide input by three"),
29 /// Error::Remainder(remainder) => write!(
31 /// "input is not divisible by three, remainder = {}",
38 /// impl std::error::Error for Error {}
40 /// fn divisible_by_3(input: &str) -> Result<(), Error> {
43 /// .map_err(|_| Error::Indivisible)
45 /// .and_then(|remainder| {
46 /// if remainder == 0 {
49 /// Err(Error::Remainder(remainder as u8))
57 /// use std::{fmt, num::ParseIntError};
61 /// Indivisible(ParseIntError),
65 /// impl fmt::Display for Error {
66 /// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
68 /// Error::Indivisible(_) => write!(f, "could not divide input by three"),
69 /// Error::Remainder(remainder) => write!(
71 /// "input is not divisible by three, remainder = {}",
78 /// impl std::error::Error for Error {
79 /// fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
81 /// Error::Indivisible(source) => Some(source),
87 /// fn divisible_by_3(input: &str) -> Result<(), Error> {
90 /// .map_err(Error::Indivisible)
92 /// .and_then(|remainder| {
93 /// if remainder == 0 {
96 /// Err(Error::Remainder(remainder as u8))
103 "`map_err` should not ignore the original error"
106 declare_lint_pass!(MapErrIgnore => [MAP_ERR_IGNORE]);
108 impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
109 // do not try to lint if this is from a macro or desugaring
110 fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
111 if e.span.from_expansion() {
115 // check if this is a method call (e.g. x.foo())
116 if let ExprKind::MethodCall(ref method, _t_span, ref args, _) = e.kind {
117 // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
118 // Enum::Variant[2]))
119 if method.ident.as_str() == "map_err" && args.len() == 2 {
120 // make sure the first argument is a closure, and grab the CaptureRef, body_id, and body_span fields
121 if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {
122 // check if this is by Reference (meaning there's no move statement)
123 if capture == CaptureBy::Ref {
124 // Get the closure body to check the parameters and values
125 let closure_body = cx.tcx.hir().body(body_id);
126 // make sure there's only one parameter (`|_|`)
127 if closure_body.params.len() == 1 {
128 // make sure that parameter is the wild token (`_`)
129 if let PatKind::Wild = closure_body.params[0].pat.kind {
130 // span the area of the closure capture and warn that the
131 // original error will be thrown away
136 "`map_err(|_|...` wildcard pattern discards the original error",
138 "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",