Multiple SFINAE class template specialisations using void_t

by

There is a rule that partial specializations have to be more specialized than the primary template – both of your specializations follow that rule. But there isn’t a rule that states that partial specializations can never be ambiguous. It’s more that – if instantiation leads to ambiguous specialization, the program is ill-formed. But that ambiguous instantiation has to happen first!

It appears that clang is suffering from CWG 1558 here and is overly eager about substituting in void for std::void_t.

This is CWG 1980 almost exactly:

In an example like

template<typename T, typename U> using X = T;
template<typename T> X<void, typename T::type> f();
template<typename T> X<void, typename T::other> f();

it appears that the second declaration of f is a redeclaration of the first but distinguishable by SFINAE, i.e., equivalent but not functionally equivalent.

If you use the non-alias implementation of void_t:

template <class... Ts> struct make_void { using type = void; };
template <class... Ts> using void_t = typename make_void<Ts...>::type;

then clang allows the two different specializations. Sure, instantiating has_members on a type that has both type1 and type2 typedefs errors, but that’s expected.

More Related Contents:

  1. C++ function template partial specialization?
  2. Why function template cannot be partially specialized?
  3. Why void_t doesnt work in SFINAE but enable_if does
  4. How does guaranteed copy elision work?
  5. What are the evaluation order guarantees introduced by C++17?
  6. What are the new features in C++17?
  7. What is the purpose of std::launder?
  8. How to assert that a constexpr if else clause never happen?
  9. What is “Expression SFINAE”?
  10. Understanding std::hardware_destructive_interference_size and std::hardware_constructive_interference_size
  11. Why should I avoid std::enable_if in function signatures
  12. Does returning a local variable return a copy and destroy the original(nrvo)?
  13. constexpr static member before/after C++17
  14. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  15. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  16. What is decltype with two arguments?
  17. Deducing first template argument with other template parameters defaulted
  18. Why is there no support for concatenating std::string and std::string_view?
  19. How to use sfinae for selecting constructors?
  20. Self-initialization of a static constexpr variable, is it well-formed?
  21. Pointer interconvertibility vs having the same address
  22. Why does aggregate initialization not work anymore since C++20 if a constructor is explicitly defaulted or deleted?
  23. Deduction guides and variadic class templates with variadic template constructors – mismatched argument pack lengths
  24. Do I need to put constexpr after else-if?
  25. Constexpr if alternative
  26. How to check if a template parameter is an iterator type or not?
  27. Partial specialization of function templates
  28. Will I be able to declare a constexpr lambda inside a template parameter?
  29. Avoiding extra move in make_unique/make_shared/emplace/etc for structures that use aggregate initialization
  30. Directly write into char* buffer of std::string

Leave a Comment