Are aliases supossed to be implicitly cross-module overloadable?

[Andrej Mitrovic]

I understand the situtation when functions from two modules compete
over a call and both are eligible for the call. In that case it's an
error (since the compiler protects against function hijacking). But in
this case, only the function from the first module is eligible for the
call.

Let me do a simple comparison to make this easier to see:

module1.d:
void foo(double)
{
}

module2.d:
void foo(string)
{
}

module3.d:
void foo(int[])
{
}

main.d:
import module1, module2, module3;

void main()
{
    foo(5.5);
}

This works fine. The functions cannot hijack each other.

Now I'll remove the import to module3 in main.d, and instead import
module3 from module2 and use an alias. The files are now:

module1.d:
void foo(double)
{
}

module2.d:
import module3;
alias module3.foo foo;

void foo(string)
{
}

module3.d:
void foo(int[])
{
}

main.d:
import module1, module2;

void main()
{
    foo(5.5);
}

But now I have a conflict:
main.d(5): Error: module1.foo at module1.d(1) conflicts with
module2.foo at module2.d(2)

Even though the functions still can't hijack each other, adding an
alias in a module seems to break compilation.

And the way to fix this, is that I need to explicitly add aliases to
the functions in main.d:

import module1, module2;

alias module1.foo foo;
alias module2.foo foo;

void main()
{
    foo(5.5);
}

So, are the aliases really needed here? Shouldn't the compiler be able
to figure out that the functions from module1.d and module2.d never
hijack each other if there's an alias in one of the modules?

On Sat, Aug 21, 2010 at 6:59 PM, Andrej Mitrovic
<andrej.mitrovich at gmail.com> wrote:
> snip