I've randomly encountered a strange error, and I cannot find any explanation for it in the official documentation of syntax.

Essentially, a class cannot call function overload in a super-class if the class itself contains an override. Is this a bug? Is this on purpose? Take a look at B.otherThing() below.

void main()
{
  abstract class A {
    // An abstract method for sub-classes
    abstract void doThing(string a, size_t b);
    // A convenience helper.
    void doThing(string a) {
      doThing(a, a.length);
    }
  }
	
  class B : A {
    // If this overload exists, something strange happens...
    override
    void doThing(string a, size_t b) {
    }
		
    void otherThing() {
      // Error: `B.doThing(string a, ulong b)`
      // is not callable using argument
      // types `(string)`
      doThing("hello");

      super.doThing("hello");  // OK
    }
  }
}

On Tuesday, 1 March 2022 at 08:40:12 UTC, Vijay Nayar wrote:

void main()
{
  abstract class A {
    // An abstract method for sub-classes
    abstract void doThing(string a, size_t b);
    // A convenience helper.
    void doThing(string a) {
      doThing(a, a.length);
    }
  }
	
  class B : A {
    // If this overload exists, something strange happens...
    override
    void doThing(string a, size_t b) {
    }
		
    void otherThing() {
      // Error: `B.doThing(string a, ulong b)`
      // is not callable using argument
      // types `(string)`
      doThing("hello");

      super.doThing("hello");  // OK
    }
  }
}

void main()
{
  abstract class A {
    // An abstract method for sub-classes
    abstract void doThing(string a, size_t b);
    // A convenience helper.
    void doThing(string a) {
      doThing(a, a.length);
    }
  }
	
  class B : A {
    // If this overload exists, something strange happens...
    override
    void doThing(string a, size_t b) {
    }

    alias doThing = typeof(super).doThing;	//add super.doThing to overload set.
		
    void otherThing() {
      // Error: `B.doThing(string a, ulong b)`
      // is not callable using argument
      // types `(string)`
      doThing("hello");

      super.doThing("hello");  // OK
    }
  }
}

On Tuesday, 1 March 2022 at 08:40:12 UTC, Vijay Nayar wrote:

Here is more info (3.): https://docarchives.dlang.io/v2.078.0/spec/function.html#function-inheritance

On Tuesday, 1 March 2022 at 09:06:59 UTC, vit wrote:

Very well spotted, thank you for that!

I'm a bit surprised at this behavior though. Do you happen to know why it is considered bad to take into account the overloads of a super-class when resolving a call in a derived-class?

On Tuesday, 1 March 2022 at 09:10:46 UTC, Vijay Nayar wrote:

https://dlang.org/articles/hijack.html