On 03/25/2010 02:00 PM, Walter Bright wrote:
------- a.d -------------------
enum FooA { fooA };
void bar(FooA x) {}
------- test.d ----------------
import a;
mixin(`
enum FooB { fooB };
void bar(FooB x) {}
`);
void test()
{
bar(FooA.fooA); //error
bar(FooB.fooB);
}
------------------------------
This error is quite correct (and happens with or without the mixin). The
idea is if you define a function in a local scope, it *completely hides*
functions with the same name in imported scopes. In order to overload
local functions with imported ones, an alias is necessary to bring the
imported functions into the same scope.
I know. It was my understanding that this entire thread was a complaint
of this behavior.
This allows the user complete control over which functions get
overloaded when they come from diverse, and possibly completely
independent, imports.
It's a very explicit form of control.
Suppose I have 10 000 enums (I don't have quite that many, but there are
a lot), each of which is in a different module because each is logically
connected to something else. Because enums in D are too spartan for my
tastes, I define a mixin to generate an enum, along with several helper
functions, like name, fromInt, toInt, etc. (Note that a way to enumerate
an enum's values would obviate all this, and __traits isn't an option in D1)
It's my understanding that enums are strongly enough typed that calling
such a helper function with an enum (or anything else) not defined for
it would generate an error. So there shouldn't be any way to hijack it.
But if I have some enum A defined in my current module and I also want
to use enums modl2.B, modl3.C, etc, then I have to manually add all those
alias modl2.name name;
<poke> or else write an IDE tool that automatically generates them for
me </poke>
I guess what I'm trying to say is it doesn't make sense that I can
implicitly import FooA, an external symbol, but not bar(FooA), an
external symbol defined on an external symbol which cannot be implicitly
converted to a local symbol.
------- a.d -------------------
enum FooA { fooA };
void bar(FooA x) {}
------- test.d ----------------
import a;
alias a.bar bar;
mixin(`
enum FooB { fooB };
void bar(FooB x) {}
`);
void test()
{
bar(FooA.fooA);
bar(FooB.fooB); //error
}
------------------------------
I'm not sure why this error is happening, it definitely has something to
do with the mixin. Let me look into it some more.
