Remove unnecessary match

[SaadiSave]

What it does

What does this lint do?

Remove unnecessary match for error handling when function signatures are the same.

Categories (optional)

• Kind: style, correctness ?

What is the advantage of the recommended code over the original code

Not sure if there are any performance improvements. The code is more readable and shorter though. This lint also applies for any function pair that returns the same enum, like Option<T> for example.

Drawbacks

None.

Example

// For example, a function has the signature:
fn fname(...) -> Result<T, E> { ... }

// and it is called in another function with the same signature:
fn fname2(...) -> Result<T, E> {
    // This is obviously unnecessary
    match fname(...) {
        Ok(s) => Ok(s),
        Err(e) => Err(e),
    }
}

Could be written as:

// For example, a function has the signature:
fn fname(...) -> Result<T, E> { ... }

// and it is called in another function with the same signature:
fn fname2(...) -> Result<T, E> {
    // Much better
    fname(...)
}

Real world example

async fn destructure_reqwest_response(res: Response) -> Result<Generic, InternalError> {
    ...
}

async fn get_count(...) -> Result<Generic, InternalError> {
    ...
    // Changed this later. Even clippy::pedantic did not detect this, so I assume that a lint is missing.
    match res {
        Ok(r) => match destructure_reqwest_response(r).await {
            Ok(r) => Ok(r),
            Err(e) => Err(e),
        },
        Err(_) => Err(INTERNALERROR),
    }
    ...
}

[giraffate]

It would be better for categories to be style.

[SaadiSave]

@giraffate
Correctness is described as code that is completely unnecessary. Don't the examples above have completely unnecessary code? What makes style a better category?

[giraffate]

code that is outright wrong or very useless

correctness is described above in README. The original code isn't wrong and doesn't seems to lead some bugs. So I think style (default warn), not correctness (default deny), is appropriate for this.

[SaadiSave]

Okay. Will change it

[SaadiSave]

Can someone estimate how complex implementing this lint is?

[camsteffen]

I think this should be correctness since it is "very useless". It could point out a bug where the coder meant to actually do something instead of nothing.

Name idea: nop_match.

Can someone estimate how complex implementing this lint is?

This should be quite easy to implement. You just need to check that, for each match arm, the body of the arm is the same as the pattern. Not quite as simple as a == b but some simple matches.

[giraffate]

It could point out a bug where the coder meant to actually do something instead of nothing.

Oh, it make sense. correctness also looks good.

[SaadiSave]

How do I go about implementing this?

[llogiq]

If I'm not mistaken, correctness lints error instead of warn. We should really add the "suspicious" lint group we suggested earlier.

[camsteffen]

@SaadiSave have you looked at the contributing docs?

[J-ZhengLi]

Since no one has claim this in almost a year, so I'll give it a try.

@rustbot claim