out-of-line implementation of a constrained inner template of a class template specialization does not match primary template

[ldalessa]

In the following code, Clang reports that it can not match the specialization with anything in the primary template. Both GCC and NVC++ (EDG+LLVM) accept this as valid.

#include <concepts>

template<bool>
struct a
{
    template<std::movable T>
    void c(T&& t);
};

template<>
template<std::movable T>
void a<true>::c(T&&t)
{}

Output:

<source>:12:15: error: out-of-line definition of 'c' does not match any declaration in 'a<true>'
void a<true>::c(T&&t)
              ^

Live example: https://godbolt.org/z/3PnKj4c75

[shafik]

I think this should be valid but I will let @erichkeane make the call.

[llvmbot]

@llvm/issue-subscribers-c-20

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[usx95]

CC @alexander-shaposhnikov who has been working on similar out-of-line definition bugs.

[alexander-shaposhnikov]

A slightly simpler reproducer:

template <class T>
concept Concept = true;

template<bool>
struct a
{
  template<Concept T>
  void c(T t);
};

template<>
template<Concept T>
void a<true>::c(T t)
{}

https://godbolt.org/z/YYKr381b8

[erichkeane]

Yep, I would expect that to work. I'm guessing we're just not comparing the constraints correctly again.

[alexander-shaposhnikov]

I'm looking into this issue, hope to have an update ~soon.

[erichkeane]

I'm looking into this issue, hope to have an update ~soon.

Ok, cool! Let me know how you go. At the moment, I've debugged it down to SemaTemplate.cpp:8138 TemplateParameterListsAreEqual isn't returning true. It is only hit 1x in your example, so at least that should be reasonably easy to hit in a debugger.

[erichkeane]

Grr... as soon as I posted that, I got us down quite a bit further :) The problem is that the 'depth' of each of these template arguments are different, but we don't have the "InstantiatedFrom" for them, since they aren't being instantiated.

See SemaTemplate.cpp:8081, which checks if the constraint expressions are equal. AreConstraintExpressionsEqual does its 'depth' equaling by checking where it was instantiated from. However, in this case, we likely need to give it the old/new declaration itself (since it is, in effect, the 'instantiated from').

Let me know if that isn't clear.