Re: ushort calls byte overload

[Daniel Kozak via Digitalmars-d-learn]

Dne 30.5.2017 v 23:16 Oleg B via Digitalmars-d-learn napsal(a):
Hello. I have this code

import std.stdio;

void foo(byte a) { writeln(typeof(a).stringof); }
void foo(short a) { writeln(typeof(a).stringof); }
void foo(int a) { writeln(typeof(a).stringof); }

void main()
{
    foo(0); // int, and byte if not define foo(int)
    foo(ushort(0)); // byte (unexpected for me)
    foo(cast(ushort)0); // byte (unexpected too)

    foo(cast(short)0); // short
    foo(short(0)); // short

    ushort x = 0;
    foo(x); // short
}

Is this a bug or I don't understand something?

It is "not" a bug, and it is how compiler works. Compiler do many 
assumptions (it is sometimes useful). So if it see something like
immutable ushort y = 0 (compile time value) or just "0" (still compile 
time value) it knows its value so it knows it can be saftly represent in 
byte, ubyte and so on.

However ushort x = 0;
foo(x); // here x is runtime value so compilere does not know the size, 
so it will use the type.

Lets look to an another example

immutable ushort y = 0;
byte x = y;

this will compile because of current rules.

but this:

ushort y = 0;
byte x = y;

will produce this error: Error: cannot implicitly convert expression (y) 
of type ushort to byte

And in this example is everything ok:

import std.stdio;

void f(ushort u)
{
    writeln("ushort");
}

void f(ubyte u)
{
    writeln("ubyte");
}

void main()
{
    ushort y = 0;
    immutable ushort x = 0;

    f(y);
    f(x);
}

RESULT IS:
ushort
ushort

but obviously in follow example it could be misleading

import std.stdio;

void f(short u)
{
    writeln("short");
}

void f(ubyte u) // or byte u
{
    writeln("ubyte or byte");
}

void main()
{
    ushort y = 0;
    immutable ushort x = 0;

    f(y);
    f(x);
}

RESULT IS:
ushort
[u]byte

But it make sense, compiler will select the best match in this case it 
is byte or ubyte but if we change x to something like 128
wi will get different results for byte and ubyte