Catch double reverses on the same iterator

What it does

Warn on code like this:

.rev().map(...).rev()

This looks like it will run the map function on the values in reverse order, then return the outputs in the original order. However, it actually just calls map() in forwards order and the two rev()s cancel each other out.

The lint should suggest changing it to .map(...), deleting the rev()s, since that is what the code actually does. It should also suggest some other solution if the user wanted to map in reverse order (such as .rev().map(...).collect() followed by .reverse()).

Advantage

Avoids confusing readers. In other languages (for example Javascript with reverse or toReverse instead of rev) the behavior is the opposite of the behavior in Rust.

Drawbacks

None

Example

let mut total: i32 = 0;
let data = [1, 2, 3, 7];
let sums_to_end: Vec<i32> = data.iter().rev().map(|x| {
  total += x;
  total
}).rev().collect();

Could be written as:

let mut total: i32 = 0;
let data = [1, 2, 3, 7];
let sums_to_end: Vec<i32> = data.iter().map(|x| {
  total += x;
  total
}).collect();

Comparison with existing lints

N/A

Additional Context

No response