Conflict in return type from base class with derived class using auto

Question

I have the following code:

struct A{};

struct Base {
    virtual A& internal() = 0;
};

struct Derives : public Base {    
    auto& internal() override { // <-- conflicting return type
        return internal_;
    }

private:
    A internal_;
};

int main() {
    Derives d;
    auto& internal = d.internal();
}

This fails to compile (tested on coliru - with gcc) with a conflicting return type - my question is why can't the compiler deduce that both internal_ (and therefore the return type) is A? Is the type deduced for auto in a different stage of compilation for example than the one which checks the virtual overrides? Of course this compiles if you replace auto with the correct type - but that is besides the point.

(Here is the clang error, gcc is somewhat similar)

main.cpp:8:11: error: return type of virtual function 'internal' is not covariant with the return type of the function it overrides ('auto &' is not derived from 'A &')

auto& internal() override { // <-- conflicting return type
~~~~~ ^

main.cpp:4:16: note: overridden virtual function is here

virtual A& internal() = 0;
        ~~ ^

1 error generated.

Answer 1

From [dcl.spec.auto]:

A function declared with a return type that uses a placeholder type shall not be virtual ([class.virtual]).

internal() is a virtual function, so you can't use auto.

The original proposal indicates the reasoning for this:

It would be possible to allow return type deduction for virtual functions, but that would complicate both override checking and vtable layout, so it seems preferable to prohibit this.