On Sunday, 15 September 2013 at 18:31:30 UTC, Marek Janukowicz
wrote:
The code to reproduce the problem consists of 3 modules:
mix.d:
module mix;
mixin template A( alias x) {
string a () {
return x;
}
}
====================
aux.d:
module aux;
import mix;
mixin A!("a in aux") X;
string b () { return "b in aux"; }
====================
main.d:
module main;
import aux;
import mix;
import std.stdio;
mixin A!("a in main") X;
string b () { return "b in main"; }
void main () {
writefln( "a: %s", X.a ); // Line 1
//writefln( "a: %s", a ); // Line 2
writefln( "b: %s", b ); // Line 3
}
I run it with: dmd -run main.d aux.d mix.d
Line 1 works. Line 3 works. Line 2 fails with:
main.d(13): Error: main.A!("a in main").a at mix.d(5) conflicts
with aux.A!
("a in aux").a at mix.d(5)
If I omit mixin identifier ("X"), there is no way I can make
the call to "a"
work without prepending module name.
My question is: why calling a function with the same name (from
different
modules) works when:
- it is just a regular function
- it is a mixed-in function with mixin identifier (even though
the
identifier is ambiguous)
and it doesn't when it's a mixed-in function with no mixin
identifier.
My first impression is that either both line 1 and 2 should
work or neither
of them should work. It's no surprise to me that line 3 works
(and it
matches the documentation), so I basically included that just
for reference.
Currently this is not a bug.
Looking from the module 'main', the mixin identifier 'X' declared
in main.d is *closer* than the 'X' declared in aux.d, because the
latter exists beyond the module import boundary.
Therefore, the use of 'X' in main.d would prefere the `mixin
A!("a in main") X`.
On the other hand, when the name search, all mixed-in symbols are
treated as if they are just imported at the mixed-in scope.
Therefore, even from main.d, the two mixed-in functions 'a' have
same closeness, and the call is ambiguous because they have
exactly same signature.
Kenji Hara