Why does this happen:
```d
void foo(long x) { }
void foo(ulong x) { }
main()
{
foo(short(17)); // error: `foo` called with argument types
`(short)` matches both: `foo(long x)` and: foo(ulong x)`
}
```
Why does a short match an unsigned type with same priority as a
signed type?!?
Clearly a longer type with matching signedness should always be a
better match than a type that will discard the sign, no?
Because of this bug I often have to make weird workarounds like:
```d
void foo(ulong x)
{
...
}
void foo(T)(T y) if(isIntegral!T && isSigned!T)
{
long x = y;
...
}
```
or vice versa.
And another problem with overloads is, that only in the current
module is searched for matches, even if functions with same name
are imported explicitly:
```d
module A;
void foo(int x) { ... }
module B;
import A : foo;
void foo(T)(T x) if(!is(Unqual!T==int))
{
...
}
main()
{
foo(-3); // error: template `foo` is not callable using
argument types `!()(int)` Candidate is: `foo(T)(T x)` with `T =
int`
must satisfy the following constraint: `!is(Unqual!T == int)`
}
```
A workaround in B is:
```d
void foo(T)(T x)
{
static if(is(Unqual!T==int) return A.foo(x); // here
explicitly a fully qualified name is required, else the compiler
doesn't find it
...
}
```
But this cannot be in A, because then again the error "matching
both" occurs.
