A constexpr virtual function rejects valid usage of CRTP type as "incomplete type" - compiles with gcc

[kirshamir]

C++20 allows constexpr virtual functions.

The following code fails to compile with clang but passes with gcc.
Turning the function foo to be non-virtual or removing the constexpr make it compile. But it should be valid also as virtual constexpr, and the type A shall be complete by the time the template argument is being used.

class Base {
    constexpr virtual void foo(const Base& b) const {}
};

template<typename ActualType, typename Base>
class CRTP: public Base {
    constexpr void foo(const Base& b) const override {
        // assume we know here for sure that b is of type const ActualType& 
        const auto& other_s = static_cast<const ActualType&>(b);
        // dynamic_cast also fails to compile in this case
        const auto& other_d = dynamic_cast<const ActualType&>(b);
        // do something with other
    }
};

class A: public CRTP<A, Base> { };

int main() {
    constexpr A a1;
}

Compilation error:

<source>:11:31: error: no viable conversion from 'const Base' to incomplete type 'const A'
   11 |         const auto& other_s = static_cast<const ActualType&>(b);
      |                               ^                              ~
<source>:18:17: note: in instantiation of member function 'CRTP<A, Base>::foo' requested here
   18 | class A: public CRTP<A, Base> {
      |                 ^
<source>:18:17: note: in instantiation of template class 'CRTP<A, Base>' requested here
<source>:18:7: note: definition of 'A' is not complete until the closing '}'
   18 | class A: public CRTP<A, Base> {
      |       ^
<source>:13:31: error: 'const A' is an incomplete type
   13 |         const auto& other_d = dynamic_cast<const ActualType&>(b);
      |                               ^           ~~~~~~~~~~~~~~~~~~~
<source>:18:7: note: definition of 'A' is not complete until the closing '}'
   18 | class A: public CRTP<A, Base> {
      |       ^
2 errors generated.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (kirshamir)

C++20 allows constexpr virtual functions.

The following code fails to compile with clang but passes with gcc.
Turning the function foo to be non-virtual or removing the constexpr make it compile. But it should be valid also as virtual constexpr, and the type A shall be complete by the time the template argument is being used.

class Base {
    constexpr virtual void foo(const Base& b) const {}
};

template<typename ActualType, typename Base>
class CRTP: public Base {
    constexpr void foo(const Base& b) const override {
        // assume we know here for sure that b is of type const ActualType& 
        const auto& other_s = static_cast<const ActualType&>(b);
        // dynamic_cast also fails to compile in this case
        const auto& other_d = dynamic_cast<const ActualType&>(b);
        // do something with other
    }
};

class A: public CRTP<A, Base> { };

int main() {
    constexpr A a1;
}

Compilation error:

<source>:11:31: error: no viable conversion from 'const Base' to incomplete type 'const A'
   11 |         const auto& other_s = static_cast<const ActualType&>(b);
      |                               ^                              ~
<source>:18:17: note: in instantiation of member function 'CRTP<A, Base>::foo' requested here
   18 | class A: public CRTP<A, Base> {
      |                 ^
<source>:18:17: note: in instantiation of template class 'CRTP<A, Base>' requested here
<source>:18:7: note: definition of 'A' is not complete until the closing '}'
   18 | class A: public CRTP<A, Base> {
      |       ^
<source>:13:31: error: 'const A' is an incomplete type
   13 |         const auto& other_d = dynamic_cast<const ActualType&>(b);
      |                               ^           ~~~~~~~~~~~~~~~~~~~
<source>:18:7: note: definition of 'A' is not complete until the closing '}'
   18 | class A: public CRTP<A, Base> {
      |       ^
2 errors generated.

[keinflue]

Both compilers behave standard-conforming:

It is unspecified whether foo, being a virtual member function, is instantiated with the class template specialization. If it is instantiated it has a point-of-instantiation immediately following the point-of-instantiation of the enclosing class template and, being a function instantiation, another point-of-instantiation at the end of the translation unit.

The point-of-instantiation of CRTP<A, Base>, being a class template specialization, is immediately before the class A: public CRTP<A, Base> { }; declaration. So, the first point-of-instantiation of foo is also before class A: public CRTP<A, Base> { }; where A is incomplete.

Given that the instantiation would be well-formed at one point-of-instantiation but not the other, the program is IFNDR.

Removing virtual removes the permission to instantiate foo with the class template specialization.

[frederick-vs-ja]

MSVC and EDG also accept this example: https://godbolt.org/z/7h6vbq69n.

[aalien]

Both compilers behave standard-conforming:

It is unspecified whether foo, being a virtual member function, is instantiated with the class template specialization. If it is instantiated it has a point-of-instantiation immediately following the point-of-instantiation of the enclosing class template and, being a function instantiation, another point-of-instantiation at the end of the translation unit.

The point-of-instantiation of CRTP<A, Base>, being a class template specialization, is immediately before the class A: public CRTP<A, Base> { }; declaration. So, the first point-of-instantiation of foo is also before class A: public CRTP<A, Base> { }; where A is incomplete.

Given that the instantiation would be well-formed at one point-of-instantiation but not the other, the program is IFNDR.

Removing virtual removes the permission to instantiate foo with the class template specialization.

I think I'm hitting the same compiler issue. Here's a very simplified example: https://godbolt.org/z/xczbGzozc

From your explanation, I really don't understand why removing constexpr affects the behaviour: without it, the code compiles. Could you explain a bit further?

[keinflue]

From your explanation, I really don't understand why removing constexpr affects the behaviour: without it, the code compiles. Could you explain a bit further?

That's coincidental. The constexpr is not relevant here from a specification perspective.

The point is that the standard permits (but doesn't require) the compiler to instantiate a virtual member function immediately when its class specialization is instantiated, in which case that happens before class A is complete.

For non-virtual functions this is different, their instantiation must be delayed until the first odr-use or use for which the existence of the function definition would affect the semantics.

[aalien]

That's coincidental. The constexpr is not relevant here from a specification perspective.

As without constexpr the compiler instantiates a virtual member function at a time which is both permitted by the standard, and convenient for the user, but a completely irrelevant specifier breaks the behaviour, I would very firmly argue that this is indeed a bug.