Add tests for ensuring we have the right impls for arithmetic traits

[clarfonthey]

The other day I noticed that Wrapping only implements Shl and co. for usize, which contradicts that without Wrapping the shift amount can be any type. So, I think it may be useful to create tests which use macros to shove together all the types we expect to have impls for and check that we're consistent there.

What I've noticed:

• For every operation three extra impls are added, with the combinations of single-level references on both sides, e.g. &T + T, T + &T, &T + &T for Add.
• Assignment ops do the same as the above, with only one extra impl, e.g. T += &T for Add.
• Add, Sub, Mul, Div, Rem exist for all int and float types with themselves
• BitAnd, BitOr, BitXor exist for all int types and bool
• Shl and Shr allow any integer type for both the left and the right side
• Neg exists for all ints and floats
• Not exists for all ints and bool
• Wrapping should mimic all of the above, where references are of the form &Wrapping<T> and not Wrapping<&T>.

Like, I wouldn't be surprised if rearranging some macros might add or remove impls for these and adding comprehensive tests might help make sure we covered everything.

[bytesnail]

This seems like a simple but useful task, I will try to finish it.

[TheSirC]

I am reformulating the task to make sure it is clear (to myself at least) :

The goal

Create tests using a set of macros to check that every numerical instances of Wrapping<T> for the following operations Op are implemented for every combination of numerical instances (i32 <-> i64, i32 <-> bool , ...) :

Op	T Op T	&T Op T	T Op &T	&T Op &T
Add*
Sub*
Mul*
Div*
Rem*
BitAnd¤
BitOr¤
BitXor¤
Shl⟊
Shr⟊
Neg*
Not¤

with :

• Op* having the integer and float types with themselves,
• Op¤ having the integer and bool types with themselves,
• Op⟊ having the integer and float types with themselves,
• T = {Integer,Float,Wrapping<T>} and &T = &{Integer,Float,Wrapping<T>}

Am I correct ?

Link to other issues

How does this relate to #23545 ?(e.g. is it possible to bypass the bug and still implement the test ? I could not see from the issue if a solution had been found)

[iluuu1994]

@rustbot claim

@TheSirC Wrapping isn't implemented for bool and f32/f64. So this is probably only useful for integer types.

[clarfonthey]

This doesn't actually fix the issue; it should be tested for all types, not just Wrapping.

[shivan1b]

Hi @clarfon ! Are you or anyone else working on adding the missed tests?

[clarfonthey]

They're free for anyone to implement right now!

[iluuu1994]

Nope, not right now. Feel free to take over. It should be pretty similar to #63692, just add the missing types (bool, fp) and operators (bit wise operators).

[shivan1b]

Thank you very much @clarfon and @iluuu1994 , I'll send a PR.

[Dylan-DPC-zz]

@rustbot unassign

[mental32]

@rustbot claim

I'll try to get a PR in by next weekend, If nothing happens past that I'm afraid I may have been too busy so [anyone] feel free to overtake 😄

[ryzokuken]

@rustbot claim

[Alexendoo]

Hi, are you still working on this issue @ryzokuken?

[ryzokuken]

@Alexendoo I'm sorry, I couldn't do it. Please feel free to reassign this.

[Alexendoo]

No worries @ryzokuken

@rustbot release-assignment