map_err mapping to same error type

[cemoktra]

What it does

Detect when map_err maps from error type E to error type E. In those situations the mapping is redundant

Advantage

• this is like a redundant operation
• mapping the error one from enum variant to another is likely not what people intend in most cases

Drawbacks

No response

Example

enum Error {
  A,
  B
}

fn source() -> Result<(), Error> { Err(Error::A) }

fn main() -> Result<(), Error> {
  source().map_err(|_| Error::A)
}

Could be written as:

fn main() -> Result<(), Error> {
  source()
}

[samueltardieu]

mapping the error one from enum variant to another is likely not what people intend in most cases

Do you have any evidence of this? Why else would they use .map_err() with the same types in the first place?

[cemoktra]

I don't know why, but i recently found a bug that was caused by mapping variant A to variant B. Ad it was not intended, it was introduced by some copy/paste where an actual mapping was required to a place where it was mapping the same type.
So it would have been helpful in my case.

[kpreid]

Another case would be .map_err(Into::into) — if the input and output types are the same, this is definitely redundant. Code changes might lead to such extraneous code if one of the two types used to be different.

For example, code like this should have a warning, but doesn't:

pub struct Er;
pub fn foo() -> Result<(), Er> {
    Ok(())
}
pub fn bar() -> Result<(), Er> {
    foo().map_err(Into::into)  // warning: unnecessary conversion
}

[samueltardieu]

Another case would be .map_err(Into::into) — if the input and output types are the same, this is definitely redundant.

Agreed, this use case could definitely be flagged as useless code. However, OP was proposing to lint any type-idempotent operation as suspicious if I understand well, which I think is less obvious:

• one may want to switch from one variant to the other, in case of an enum
• one may want to enrich a struct with some extra information
• one may use .map_err() as .inspect_err(), which was only introduced in Rust 1.76.0

[samueltardieu]

@kpreid Your use case .map_err(Into::into) should be handled through #13756, as an extension of the useless_conversion lint.