Auto non-type template parameter: ambiguous partial specializations in Clang

Question

Clang (7, 8, trunk) rejects the following code

enum class E {};
inline static constexpr auto e = E{};
// inline static constexpr auto e = nullptr;

template<auto, int> class S;
template<int a, int b> class S<a, b> {};
template<int b> class S<e, b> {};

int main() {
    S<0, 0> s;
}

with an error:

 error: ambiguous partial specializations of 'S<0, 0>' note: partial specialization matches [with a = 0, b = 0] template<int a, int b> class S<a, b> {}; ^ note: partial specialization matches [with b = 0] template<int b> class S<e, b> {}; ^ 

1. Why is it ambiguous? How can e match 0 ? If I replace E{} with nullptr , Clang stops complaining. This looks like a Clang's bug. GCC compiles it just fine.

2. If it is a bug, what is a workaround? In my case, the auto parameter can be either E (and only one value E{} ) or int . Then:

    template<auto, int, typename> class S_impl; template<int a, int b> class S_impl<a, b, int> {}; template<int b> class S_impl<e, b, E> {}; template<auto a, int b> using S = S_impl<a, b, decltype(a)>; 

   Is there a more succinct way?

Answer 1

Clang is doing the deduction wrong. It is similar to this bug , linked to this question (not exactly identical as you are using auto in template parameters which will prevent you to compile using stdc++14).

An interesting case is that it is not the case if it's a complete specialization; only on partial specialization :

#include <iostream>

enum class E {};
inline static constexpr auto e = E{};

template <auto a, int b>
class FOO;
template <int a, int b > class FOO<a, b> {};
template <int b> class FOO<e, b> {};

template <auto a, int b>
class BAR;
template <int a, int b > class BAR<a, b> {};
template <> class BAR<e, 0> {};

template <auto a>
class BAZ;
template <int a> class BAZ<a> {};
template <> class BAZ<e> {};

int main() {
    // FOO <0, 0> foo; // <= Not Ok
    BAR<0, 0> bar; // <= Ok
    BAZ<0> baz; // <= Ok
}

Any solution that force the deduction of the type template parameter will work therefore your suggested solution is perfectly valid. IMHO, I would avoid using auto in template parameter when not necessary to improve readability :

template <typename T, T value, int> class S_impl; // <= this auto is not necessary
template <int a, int b> class S_impl<int, a, b> {};
template <int b> class S_impl<E, e, b> {};
// Either define S to use S<0,0> or directly use S_impl<int, 0, 0>
template <auto a, int b> using S = S_impl<decltype(a), a, b> // <= this auto is necessary