Declare std::tuple_element as struct instead of class

[jdoerrie]

Summary

Similarly to https://reviews.llvm.org/rL350972 this revision changes std::tuple_element from class to struct. Fixes PR#41331.

[mclow.lists]

Did you check the places that inherit from tuple_element? The public/private bits change between class and struct.

[mclow.lists]

In D60069#1449928, @mclow.lists wrote:

Did you check the places that inherit from tuple_element? The public/private bits change between class and struct.

Never mind. I was thinking of something else; I don't think that anything inherits from tuple_element

[jdoerrie]

In D60069#1449932, @mclow.lists wrote:

In D60069#1449928, @mclow.lists wrote:

Did you check the places that inherit from tuple_element? The public/private bits change between class and struct.

Never mind. I was thinking of something else; I don't think that anything inherits from tuple_element

Right, there shouldn't be any inheritance. Some of the public: access specifications are now redundant, though. Instead of

template <size_t I, class... Types>
struct tuple_element<I, tuple<Types...> >
{
public:
    typedef Ti type;
};

we could now simply say

template <size_t I, class... Types>
struct tuple_element<I, tuple<Types...> >
{
    typedef Ti type;
};

[mclow.lists]

In D60069#1449937, @jdoerrie wrote:

Right, there shouldn't be any inheritance. Some of the public: access specifications are now redundant, though.

And I think that you should get rid of them.

[ldionne]

In D60069#1449937, @jdoerrie wrote:

Right, there shouldn't be any inheritance. Some of the public: access specifications are now redundant, though.

Can you please fix those?

[jdoerrie]

Remove redundant public: access controls

[mclow.lists]

I'm less enthusiastic about this change than the one for PR39871, because there we were being inconsistent with ourselves.
However, my lack of enthusiasm is no reason not to land this.

[jdoerrie]

In D60069#1449979, @mclow.lists wrote:

I'm less enthusiastic about this change than the one for PR39871, because there we were being inconsistent with ourselves.
However, my lack of enthusiasm is no reason not to land this.

Thank you for accepting. I understand your point, but you could argue that this change fixes a inconsistency between tuple_size and tuple_element. As I don't think I have commit access, could one of you commit this change for me?

include/__tuple

 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
 #endif
 
-template <size_t _Ip, class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_element;
+template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element;
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
 {
-public:
     typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
 {
-public:
     typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
 {
-public:
     typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 

 #endif
 
 template <size_t _Ip, class ..._Types>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...>>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...>>
 {
-public:
     static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
     typedef __type_pack_element<_Ip, _Types...> type;
 };

 
 
 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
 {
-public:
     typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
 };
 

include/array

   void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // C++17
 
 template <class T> struct tuple_size;
-template <size_t I, class T> class tuple_element;
+template <size_t I, class T> struct tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
 template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14

     : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
-public:
     typedef _Tp type;
 };
 

include/span

 
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, span<_Tp, _Size>>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, span<_Tp, _Size>>
 {
     static_assert( dynamic_extent != _Size, "std::tuple_element<> not supported for std::span<T, dynamic_extent>");
     static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::span)");
-public:
     typedef _Tp type;
 };
 

include/tuple

 template <class... T> struct tuple_size<tuple<T...>>;
 template <class T>
  inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
-template <size_t I, class T> class tuple_element; // undefined
-template <size_t I, class... T> class tuple_element<I, tuple<T...>>;
+template <size_t I, class T> struct tuple_element; // undefined
+template <size_t I, class... T> struct tuple_element<I, tuple<T...>>;
 template <size_t I, class T>
   using tuple_element_t = typename tuple_element <I, T>::type; // C++14
 

include/utility

 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
 template <class T> struct tuple_size;
-template <size_t I, class T> class tuple_element;
+template <size_t I, class T> struct tuple_element;
 
 template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
 template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;

     : public integral_constant<size_t, 2> {};
 
 template <size_t _Ip, class _T1, class _T2>
-class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
 {
     static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
+struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
 {
-public:
     typedef _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
+struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
 {
-public:
     typedef _T2 type;
 };
 

test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp

 // template <class... Types> class tuple;
 
 // template <size_t I, class... Types>
-// class tuple_element<I, tuple<Types...> >
+// struct tuple_element<I, tuple<Types...> >
 // {
-// public:
 //     typedef Ti type;
 // };
 //

test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp

 // template <class... Types> class tuple;
 
 // template <size_t I, class... Types>
-// class tuple_element<I, tuple<Types...> >
+// struct tuple_element<I, tuple<Types...> >
 // {
-// public:
 //     typedef Ti type;
 // };
 

test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp

 // template <class... Types> class tuple;
 
 // template <size_t I, class... Types>
-// class tuple_element<I, tuple<Types...> >
+// struct tuple_element<I, tuple<Types...> >
 // {
-// public:
 //     typedef Ti type;
 // };
 

test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp

 int get(Test const&) { static_assert(N == 0, ""); return -1; }
 
 template <>
-class std::tuple_element<0, Test> {
-public:
+struct std::tuple_element<0, Test> {
   typedef int type;
 };