Consider changing return type of `div` and `divrem` for `(::Unsigned, ::Signed)`

[oscardssmith]

Currently we have

julia> div(UInt(1), -1)
0xffffffffffffffff

This happens because we are returning the promote_type, but violates both common sense, and the documentation which states "Generally equivalent to a mathematical operation x/y without a fractional part".

As such, I propose that we instead make the return type of div(x,y) be ifelse(isa(y, Signed), signed(promote_type(x,y)), promote_type(x,y)). This would obviously be slightly breaking, but I think it qualifies as a bugfix.

We also would want to make similar changes for divrem, fld, cld since they all have the same problem.

[KlausC]

But that would produce silently wrong results for huge x and y == 1:

julia> div2(x::Unsigned, y::Signed) = div(signed(x), y)
div2 (generic function with 1 method)

julia> div2(typemax(UInt), 1) #  typemax(UInt) would be correct mathmatically.
-1
``

[oscardssmith]

yeah good point. I guess a relatively decent option would be to OverflowError. div is right on the edge of where an error is cheap enough...

[KlausC]

I propose rather to throw runtime Exceptions in all cases of the division operations (as in done for fld1), if no result according to the mathematical specs of the functions can be returned.
That is independent of the return type, we chose finally.

[KlausC]

And don't forget fldmod, fldmod1

I think, the return type Q for the quotient could always be the type S of the first argument. Example for div.
Proof:

1. div(x::S, one(T)) == x should be true for all integer types S and T. So Qmust be able to represent all values thatS` can.
2. Also div(zero(S), y) == zero(S) is covered by that Q for y != 0.
3. For any second argument y > 1 the type S can store the correct result value, independent of T.
4. For y < 0 and S <: Unsigned, the correct result is negative. If we want Q to store that value, Q must be at least widen(signed(S)), what is probably not acceptable, so in this case an Error should be thrown.
5. For y < 0 and S <:Signed all quotients can be stored in S, except for x == typemin(S) and y == -1; again if we don't want to widen the result, an Error should be thrown.
6. The case y == 0 should as already done, throw DivideError, independent of Sand T.

In the presence of type promotion, Q = promote_type(S, signed(T)) would be appropriate for all cases, meaning the signedness of Tcan be ignored.

The current implementation uses the promoted type, but does not throw in in all cases described above.

[LilithHafner]

Triage thinks that the funky behavior here should be documented but we don't want to add a breaking edge case or add an exception to promotion.

[KlausC]

I believe in common sense like I believe in miracles. But common sense discourages me to believe in miracles.