[Bug c++/67164] ICE: tree check: expected class ‘expression’, have ‘exceptional’ (argument_pack_select) in tree_operand_check, at tree.h:3356

[trippels at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67164

Markus Trippelsdorf <trippels at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jason at gcc dot gnu.org

--- Comment #3 from Markus Trippelsdorf <trippels at gcc dot gnu.org> ---
Here's another testcase: 

namespace std {
template <typename _Tp> struct A { static constexpr _Tp value = 0; };
template <bool, typename, typename> struct conditional;
template <typename...> struct B;
template <typename _B1, typename _B2>
struct B<_B1, _B2> : conditional<1, _B1, _B2> {};
template <typename...> struct C;
template <typename _B1, typename _B2>
struct C<_B1, _B2> : conditional<1, _B2, _B1> {};
template <typename> struct D;
template <typename _Tp> struct I : B<A<bool>, D<_Tp>>::type {};
template <typename _Tp> _Tp declval();
struct F {
  template <typename _Tp, typename _Arg,
            typename = decltype(_Tp(declval<_Arg>()))>
  static A<bool> __test(int);
};
template <typename _Tp, typename _Arg> struct J : F {
  decltype(__test<_Tp, _Arg>(0)) type;
};
template <typename _Tp, typename _Arg> struct K : C<int, J<_Tp, _Arg>> {};
template <typename _Tp, typename _Arg>
struct L : conditional<I<_Tp>::value, int, K<_Tp, _Arg>> {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible : L<_Tp, _Arg>::type {};
template <typename...> struct G;
template <typename _Tp, typename _Arg>
struct G<_Tp, _Arg> : __is_direct_constructible<_Tp, _Arg> {};
template <typename _Tp, typename... _Args>
struct is_constructible : G<_Tp, _Args...>::type {};
template <bool> struct enable_if;
template <bool, typename _Iftrue, typename> struct conditional {
  typedef _Iftrue type;
};
template <typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse> {
  typedef _Iffalse type;
};
}
namespace detail {
template <bool> struct fast_and;
template <typename... Xn> struct closure {
  template <typename... Yn,
            typename = std::enable_if<
                fast_and<std::is_constructible<Xn, Yn>::value...>::value>>
  closure(Yn...);
  template <typename... Yn> closure(closure<Yn...>);
};
}
template <typename> struct make_impl;
template <typename Datatype> struct H {
  template <typename... X> decltype(auto) operator()(X... x) {
    return make_impl<Datatype>::apply(x...);
  }
};
template <typename Datatype> H<Datatype> make;
struct Tuple;
template <typename... Xs> struct M : detail::closure<Xs...> {
  using detail::closure<Xs...>::closure;
};
template <> struct make_impl<Tuple> {
  template <typename... Xs> static M<Xs...> apply(Xs...);
};
namespace test {
struct {
  template <typename... Xs> decltype(auto) operator()(Xs... xs) {
    auto storage = make<Tuple>(xs...);
    return storage;
  }
} seq;
}
int main() { test::seq(test::seq()); }