DIP66 - Multiple alias this

[IgorStepanov via Digitalmars-d]

On Tuesday, 28 October 2014 at 02:07:23 UTC, Andrei Alexandrescu 
wrote:
> On 10/24/14 6:05 AM, IgorStepanov wrote:
>> On Friday, 24 October 2014 at 06:04:24 UTC, Andrei 
>> Alexandrescu wrote:
>>> On 10/19/14 2:00 PM, IgorStepanov wrote:
>>>> Bump.
>>>
>>> I've made a few grammar and fluency edits to the DIP, and 
>>> collected a
>>> few thoughts while doing that. Will get back on this before 
>>> too long.
>>> -- Andrei
>>
>> I've seen it. Thanks!
>> Waiting for a comments.
>
> Coming soon. I've been under quite a bit of pressure as of late.
>
>> Should I add chapter about method overloading with alias this: 
>> it should
>> work (and works) as cross-module overloading. It should imply
>> This implies from the DIP but hasn't written explicitly.
>
> Interesting. I think it should work like overloading of calls 
> in base and derived classes.

Not really. Rules which define overloading class methods doesn't 
describe multiple inheritance case.
In single inheritance case alias this rule is similar with 
inheritance rule: derived overload set hides base base overload 
set:

struct A
{
     void foo(string)
     {
         writeln("string");
     }

     void foo(int)
     {
         writeln("int");
     }
}

struct B
{
     void foo(double)
     {
         writeln("double");
     }

     A a;
     alias a this;
}

B b;
b.foo("string"); //error
b.foo(42); //called B.foo(double), not B.a.foo(int);

The second test is not similar to inherintance rules, but this 
case is not relevant with multiple alias this and it is already 
done.

When I said "cross-module overloading", I told about case when C 
inherits (via alias this) A and B, both A and B have "foo" 
methods with different paramethers and compiler should resolve 
foo call:

struct A
{
     void foo(string)
     {
         writeln("string");
     }

     void foo(int)
     {
         writeln("int");
     }
}


struct B
{
     void foo(double)
     {
         writeln("double");
     }
}

struct C
{
      A a;
      B b;
      alias a this;
      alias b this;
}

C c;
c.foo("str"); // OK, c.a.foo(string)
c.foo(4.2); //OK, c.b.foo(double);
c.foo(42); //Error: c.a.foo(int) or c.b.foo(double)?

BTW, similar case with multiple inheritance via interfaces works 
absolutely incorrect:

interface CA
{
     final void foo(string)
     {
         writeln("string");
     }

     final void foo(int)
     {
         writeln("int");
     }
}

interface CB
{
      final void foo(double)
      {
          writeln("double");
      }
}

class CC : CA, CB
{

}

auto cc = new CC();
cc.foo("xxx"); //OK, called CA.foo(string)
cc.foo(42); //called CA.foo(int) without any warnings
cc.foo(4.2); //Error: unable to call CA.foo with double argument.

In other words, compiler choses the first base interface, uses 
its overload set and ignores other interfaces.

>> OT: Should `et\s?c\.?` be written as "etc" in English?
>> I thought that it should be written as "et c.", because "et 
>> cetera". Or
>> is it an anachronism?
>
> You can't go wrong with M-W: 
> http://www.merriam-webster.com/dictionary/etc

Thanks.