Automatic method overriding in sub-classes

[Tofu Ninja via Digitalmars-d]

On Tuesday, 27 October 2015 at 22:23:15 UTC, bitwise wrote:
> [...]
> I just did a test for this. Using dmd's -H flag to generate 
> header files, the bodies of member functions are removed. If 
> you link a static library containing the compiled class though, 
> everything will work, and you can still inherit the class.
>
> [test.d]
> module test;
> import std.stdio;
> class Test { void foo() { writeln("test"); } }
> [/test.d]
>
> [main.d]
> module main;
> import test;
> import std.stdio;
> class Derived : Test {
>     override void foo() { writeln("derived"); }
> }
> void main() {
>     Derived d = new Derived();
>     d.foo(); // prints "derived"
> }
> [/main.d]
>
> With the above two files, I did this:
>
> dmd test.d -lib -H
> rm test.d   #make sure dmd can't find body of foo()
> dmd main.d test.a
> ./main
>
> The above will print "derived".
>
> I think dmd -H should definitely keep the definitions of auto 
> override functions when generating headers, but in theory,

-H also keeps the body of template functions so I would assume it 
would treat auto overrides the same.

> someone could remove them, and things could still work. If 
> someone received a static library and a D header file with 
> missing auto override function, they wouldn't be able to 
> inherit from the class, as if it were a sealed/final class. 
> This person, however, could work around the problem by 
> overriding the missing auto override function. I suppose this 
> is a good reason to adopt the semantics you are recommending, 
> where overriding an auto override function stops the automatic 
> behaviour, or else someone would have to override missing auto 
> override functions for every single level of inheritance after 
> the missing auto override. I suppose that if someone wanted to 
> resume the auto overrides, they could just override with 
> another auto override, and call the base class implementation 
> from their new override. With regards to the resuming of auto 
> overriding though, I'm wondering if what I am proposing is 
> possible in D. In C++, you can call any base method from 
> anywhere in a class hierarchy. In D however, it doesn't seem to 
> work.

I think you are correct, there is a scenario where one might want 
to provide a header to a class and not include the auto override 
body. An alternative solution could be that if you provide a 
header to a class and don't include the auto override body, then 
the auto override functionality is removed and the method is 
treated as a regular method from that point on(with the most 
recent version of the method being the one that is used). This 
would allow the class to still be inherited later on.

> [C++ ]
> struct A { virtual void foo() { printf("A\n"); } };
> struct B : public A { void foo() { printf("B\n"); } };
> struct C : public B { void foo() { A::foo(); } };
> int main() {
> 	C c;
> 	c.foo();   // prints "A"
> }
> [/C++]
>
> In D however, the following will cause a compiler error:
> "Error: identifier expected following '.', not 'super'"
>
> [D]
> class A { void foo() { writeln("A"); } }
> class B : A { override void foo() { writeln("B"); } }
> class C : B { override void foo() { super.super.foo(); } }
> void main() {
>     C c = new C();
>     c.foo();
> }
> [/D]
>
>     Bit

A.foo() or B.foo() seems to work instead of super.super.foo() or 
super.foo()