[temp.res.general] Unclear and incomplete requirement that packs must possibly be non-empty

[Halalaluyafail3]

Full name of submitter (unless configured in github; will be published with the issue): Jay Ghiron

Reference (section label): [temp.res.general]/6

Issue description:

The program is ill-formed, no diagnostic required, if
...
every valid specialization of a variadic template requires an empty template parameter pack, or

There seem to be several issues with this text:

1. It makes programs which do static_assert(!sizeof...(pack)) IFNDR, which seems unintended.
2. If a template does static_assert(false), then it has no valid specializations so vacuously it is IFNDR because of this wording.
3. It seems to make the following program IFNDR, for no apparent reason:

template<typename...T,typename...U>void foo(U...){
    int x[!sizeof...(T)!=!sizeof...(U)];//exactly one pack must be empty
}

4. This does not apply to structured binding packs, even though existing implementations apply the same restrictions:

void foo(auto x){
    auto[...y]=x;
    union U:decltype(y)...{};//unions cannot have base classes, requires y be an empty pack
}
int main(){
    struct S{};
    foo(S{});
}

5. It is unclear if this requirement makes zero dimensional mdspans IFNDR because of [mdspan.mdspan.members]/1:

Constraints:
...
sizeof...(OtherIndexTypes) == rank() is true

For the last point, it is unclear whether or not "every valid specialization" of a member function template in a class template refers to just the valid specializations for one member function template in a particular specialization of the class template, or instead collectively to all valid specializations of the member function templates for all specializations of the class template.

[jensmaurer]

If a template does static_assert(false), then it has no valid specializations so vacuously it is IFNDR because of this wording.

Looks like the bullet 1-3 phrasing should be applied to bullet 6 as well.

[Halalaluyafail3]

Another issue I realized is that:

template<typename...,typename...>void foo(){}

It is unclear if "every valid specialization" includes impossible to spell specializations. In this example there is nothing that would require either pack to be empty, however it is impossible to actually create a specialization that has the second pack containing anything.

This issue and the fifth point also seem applicable to the other bullets, for example:

#include<concepts>
template<typename T>struct S{
    template<typename U>void foo()requires std::same_as<T,int>{}//S<float>::foo has no valid specializations
    template<typename>S(){}//it is impossible to create a specialization of this constructor
};

Perhaps it would make sense to split this into another issue.

[Halalaluyafail3]

Here is another example of when the fifth point would apply:

template<auto f>auto g=[](auto...x){
    f(x...);
};
void h(){}
int main(){
    g<h>();
}

g<h> is creating a closure type whose call operator is a template that can only be invoked with an empty template parameter pack.