GCC/CLang disagree on partial specialization of template template parameter

Question

GCC and clang disagree about this code.

#include <type_traits>

template <typename T, template <typename...> typename Tpl> 
struct storage {
    using type_t = T;

    template <typename... Args>
    using storage_tpl = Tpl<Args...>;
};

template <typename T, template <typename...> typename>
struct F{
    constexpr static int x = 1;
};

template <typename T >
struct F<T, std::void_t>{
    constexpr static int x = 2;
};

int f() {
    using S = storage<int, std::void_t>;

    static_assert(F<int, S::storage_tpl>().x == 2);

    return F<int, S::storage_tpl>().x;
}

According to clang S::storage_tpl is not std::void_t; of consequence it selects the primary template F instead of the partial specialization and thus the assert.

At first glance, it looks like GCC is right because it understands that the nested template is just an alias for std::void_t but maybe it is too smart and the standard requires that S::storage_tpl and std::void_t must be two different templates.

Who is right?

It is not proper reference for such case, but wording used in https://en.cppreference.com/w/cpp/language/type_alias "An alias template is a template which, when specialized, is equivalent to the result of substituting the template arguments of the alias template for the template parameters in the type-id" would mean that `storage_tpl` is independent template which happens to behave the same as `std::void_t` — R2RT, Oct 09 '18 at 17:06
Interesting. If you want simplify a little, you can remove the `typename T` argument from `storage` (removing also `type_t`, obviously) and from `F`. The disagreement between g++ and clang++ remain. — max66, Oct 09 '18 at 18:04
In [temp.class.spec.match]/2 it is said *if the template arguments of the partial specialization can be [deduced](http://eel.is/c++draft/temp.deduct) from the actual template argument list*, where deduced is a link to [temp.deduct] where... there is nothing about deduction of template argument from a template parameter (which makes sense because [temp.deduct] part is under *function template specialization*. I think the standard is underspecified. More over there is a part in the standard called *Type Equivalence* under *Template* but there is no specification for *Template Equivalence*. — Oliv, Oct 09 '18 at 18:27
alias template in combination with template template parameter is non-deduced context, basically you end up with the same problem (partial ordering and non-deduced context) as in this thread https://stackoverflow.com/questions/52462410/sfinae-template-specialization-precedence. — , Oct 09 '18 at 18:48
@Oliv: Nothing prevents deducing a template template-parameter from a function argument, or even from [such a template argument used to form a function argument’s type](http://eel.is/c++draft/temp.deduct.type#21). But neither are we trying to deduce one: the issue here is checking for a match, and that’s not specified for non-types. — Davis Herring, Oct 09 '18 at 23:10

score 4 · Answer 1 · answered Oct 10 '18 at 14:46

It looks like this is unspecified at the moment and h/t to T.C. it looks like this is covered by CWG defect report 1286 which says:

Issue 1244 was resolved by changing the example in 17.5 [temp.type] paragraph 1 from
 template<template<class> class TT> struct X { };
  template<class> struct Y { };
  template<class T> using Z = Y<T>;
  X<Y> y;
  X<Z> z;
to
  template<class T> struct X { };
  template<class> struct Y { };
  template<class T> using Z = Y<T>;
  X<Y<int> > y;
  X<Z<int> > z;
In fact, the original intent was that the example should have been correct as written; however, the normative wording to make it so was missing. The current wording of 17.6.7 [temp.alias] deals only with the equivalence of a specialization of an alias template with the type-id after substitution. Wording needs to be added specifying under what circumstances an alias template itself is equivalent to a class template.

and proposed the following resolution:

Add the following as a new paragraph following 17.6.7 [temp.alias] paragraph 2:

When the type-id in the declaration of alias template (call it A) consists of a simple-template-id in which the template-argument-list consists of a list of identifiers naming each template-parameter of A exactly once in the same order in which they appear in A's template-parameter-list, the alias template is equivalent to the template named in the simple-template-id (call it T) if A and T have the same number of template-parameters. [Footnote: This rule is transitive: if an alias template A is equivalent to another alias template B that is equivalent to a class template C, then A is also equivalent to C, and A and B are also equivalent to each other. —end footnote] [Example:
  template<typename T, U = T> struct A;

  template<typename V, typename W>
    using B = A<V, W>;                // equivalent to A

  template<typename V, typename W>
    using C = A<V>;                   // not equivalent to A:
                                      // not all parameters used

  template<typename V>
    using D = A<V>;                   // not equivalent to A:
                                      // different number of parameters

  template<typename V, typename W>
    using E = A<W, V>;                // not equivalent to A:
                                      // template-arguments in wrong order

  template<typename V, typename W = int>
    using F = A<V, W>;                // equivalent to A:
                                      // default arguments not considered

  template<typename V, typename W>
    using G = A<V, W>;                // equivalent to A and B

  template<typename V, typename W>
    using H = E<V, W>;                // equivalent to E

  template<typename V, typename W>
    using I = A<V, typename W::type>; // not equivalent to A:
                                      // argument not identifier
—end example]

but there are issues with this resolution and the defect report is still active.

GCC/CLang disagree on partial specialization of template template parameter

1 Answers1