Class template specialization partial ordering and function synthesis

Question

The rules for picking which class template specialization is preferred involve rewriting the specializations into function templates and determining which function template is more specialized via the ordering rules for function templates [temp.class.order]. Consider this example, then:

#include <iostream>  template <class T> struct voider { using type = void; }; template <class T> using void_t = typename voider<T>::type;  template <class T, class U> struct A { };  template <class T> int foo(A<T, void_t<T>> ) { return 1; } template <class T> int foo(A<T*, void> )     { return 2; }  int main() {     std::cout << foo(A<int*, void>{}); } 

Both gcc and clang print 2 here. This makes sense with some previous examples - deducing against a non-deduced context (void against void_t<T>) is just ignored, so deducing <T, void_t<T>> against <X*, void> succeeds but deducing <T*, void> against <Y, void_t<Y>> fails in both arguments. Fine.

Now consider this generalization:

#include <iostream>  template <class T> struct voider { using type = void; }; template <class T> using void_t = typename voider<T>::type;  template <int I> struct int_ { static constexpr int value = I; };  template <class T, class U> struct A      : int_<0> { }; template <class T> struct A<T, void_t<T>> : int_<1> { }; template <class T> struct A<T*, void>     : int_<2> { };  int main() {     std::cout << A<int*, void>::value << '\n'; } 

Both clang and gcc report this specialization as ambiguous, between 1 and 2. But why? The synthesized function templates aren't ambiguous. What's the difference between these two cases?

Answer 1

Clang is being GCC-compatible (and compatible with existing code that depends on both of these behaviors).

Consider [temp.deduct.type]p1:

[...] an attempt is made to find template argument values (a type for a type parameter, a value for a non-type parameter, or a template for a template parameter) that will make P, after substitution of the deduced values (call it the deduced A), compatible with A.

The crux of the issue is what "compatible" means here.

When partially ordering function templates, Clang merely deduces in both directions; if deduction succeeds in one direction but not the other, it assumes that means the result will be "compatible", and uses that as the ordering result.

When partially ordering class template partial specializations, however, Clang interprets "compatible" as meaning "the same". Therefore it only considers one partial specialization to be more specialized than another if substituting the deduced arguments from one of them into the other would reproduce the original partial specialization.

Changing either of these two to match the other breaks substantial amounts of real code. :(