Suggest replacing hand made integer rotations with rotate_right/rotate_left

[leonardo-m]

I think Clippy should suggest to replace integer rotations like:

pub fn rol24a(x: u32) -> u32 {
    (x >> 8) | (x << 24)
}

With calls to rotation methods rotate_right or rotate_left:

pub fn rol24b(x: u32) -> u32 {
    x.rotate_right(8)
}

[phansch]

The docs say that rotate_left/right is not the same as the << shifting operator. Could you perhaps elaborate a bit here?

[leonardo-m]

It's true that a single shift isn't the same as a rotation. But here I didn't write a shift, I've written two shifts plus an Or. That implements a rotation on the bits. The first shift rotates, the second takes the rotates bits and the Or glues them together, performing the rotation.

[llogiq]

The easy part is detecting an or of two shifts of the same value in different directions. The hard part is checking whether the shifts add up to the type's bit width.

Consider (a << i) | (a >> (32 - i)) or even (a << i) | (a >> (31 ^ i)). And there are other ways to write this.

[CodeOpsMax]

Hey folks, I'm looking around for a good first issue to solve and give something back to the rust community.
I've started to dive a little bit deeper into how to implement this lint. As @llogiq already mentioned it is pretty simple to detect the generic pattern of two shifts of the same value in different directions. But things getting tricky when it comes to verifying that the shifts add up to the types bitwidth, since I think at the position of (32-i) there could be any function that possibly returns the correct value. The only way I could think of is matching "known" patterns like (32-i) and (32 ^ i).
So somehow my question is: Should be (a << i) | (a >> some_function(input)) or (a << i) | (a >> Mystruct.value) also considered as possible handcrafted implementation for integer rotation? A pattern like (x >> 8) | (x << 24) is somehow the simplest case since one could just verify that literal values adding up to x's bitwidth.

[frp]

@rustbot claim