Address review comments

Author: miscco

libcudacxx/include/cuda/std/__complex/tuple.h

@@ -33,11 +33,11 @@
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <class _Tp>
-struct tuple_size<complex<_Tp>> : ::cuda::std::integral_constant<size_t, 2>
+struct tuple_size<complex<_Tp>> : integral_constant<size_t, 2>
 {};
 
 template <size_t _Index, class _Tp>
-  struct tuple_element<_Index, complex<_Tp>> : ::cuda::std::enable_if < _Index<2, _Tp>
+struct tuple_element<_Index, complex<_Tp>> : enable_if<(_Index < 2), _Tp>
 {};
 
 template <class _Tp>
@@ -100,16 +100,6 @@ template <size_t _Index, class _Tp>
   return __get_complex_impl<_Tp>::template get<_Index>(::cuda::std::move(__z));
 }
 
-#if _CCCL_HAS_HOST_STD_LIB()
-template <class _Tp>
-struct tuple_size<::std::complex<_Tp>> : ::cuda::std::integral_constant<size_t, 2>
-{};
-
-template <size_t _Index, class _Tp>
-  struct tuple_element<_Index, ::std::complex<_Tp>> : ::cuda::std::enable_if < _Index<2, _Tp>
-{};
-#endif // _CCCL_HAS_HOST_STD_LIB()
-
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

libcudacxx/include/cuda/std/__tuple_dir/tuple_element.h

@@ -20,12 +20,17 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/array.h>
+#include <cuda/std/__fwd/complex.h>
+#include <cuda/std/__fwd/pair.h>
 #include <cuda/std/__fwd/tuple.h>
 #include <cuda/std/__tuple_dir/tuple_indices.h>
 #include <cuda/std/__tuple_dir/tuple_types.h>
 #include <cuda/std/__type_traits/add_const.h>
 #include <cuda/std/__type_traits/add_cv.h>
 #include <cuda/std/__type_traits/add_volatile.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/type_list.h>
 #include <cuda/std/cstddef>
 
@@ -60,7 +65,7 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, const volatile _Tp>
 template <size_t _Ip, class... _Types>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, __tuple_types<_Types...>>
 {
-  static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
+  static_assert(_Ip < sizeof...(_Types), "cuda::std::tuple_element index out of range");
   using type _CCCL_NODEBUG_ALIAS = __type_index_c<_Ip, _Types...>;
 };
 
@@ -71,6 +76,19 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, tuple<_Tp...>>
 };
 
 #if _CCCL_HAS_HOST_STD_LIB()
+template <size_t _Ip, class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, ::std::array<_Tp, _Np>> : enable_if<(_Ip < _Np), _Tp>
+{};
+
+template <size_t _Ip, class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, ::std::complex<_Tp>> : enable_if<(_Ip < 2), _Tp>
+{};
+
+template <size_t _Ip, class _T1, class _T2>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT
+tuple_element<_Ip, ::std::pair<_T1, _T2>> : enable_if<(_Ip < 2), conditional_t<_Ip == 0, _T1, _T2>>
+{};
+
 template <size_t _Ip, class... _Tp>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, ::std::tuple<_Tp...>>
 {

libcudacxx/include/cuda/std/__tuple_dir/tuple_size.h

@@ -20,6 +20,9 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/array.h>
+#include <cuda/std/__fwd/complex.h>
+#include <cuda/std/__fwd/pair.h>
 #include <cuda/std/__fwd/tuple.h>
 #include <cuda/std/__tuple_dir/tuple_types.h>
 #include <cuda/std/__type_traits/enable_if.h>
@@ -64,12 +67,6 @@ template <class... _Tp>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<tuple<_Tp...>> : public integral_constant<size_t, sizeof...(_Tp)>
 {};
 
-#if _CCCL_HAS_HOST_STD_LIB()
-template <class... _Tp>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::tuple<_Tp...>> : public integral_constant<size_t, sizeof...(_Tp)>
-{};
-#endif // _CCCL_HAS_HOST_STD_LIB()
-
 template <class... _Tp>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT
 tuple_size<__tuple_types<_Tp...>> : public integral_constant<size_t, sizeof...(_Tp)>
@@ -78,6 +75,25 @@ tuple_size<__tuple_types<_Tp...>> : public integral_constant<size_t, sizeof...(_
 template <class _Tp>
 inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
 
+#if _CCCL_HAS_HOST_STD_LIB()
+template <class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::array<_Tp, _Np>> : public integral_constant<size_t, _Np>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::complex<_Tp>> : integral_constant<size_t, 2>
+{};
+
+template <class _T1, class _T2>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::pair<_T1, _T2>> : public integral_constant<size_t, 2>
+{};
+
+template <class... _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::tuple<_Tp...>> : public integral_constant<size_t, sizeof...(_Tp)>
+{};
+
+#endif // _CCCL_HAS_HOST_STD_LIB()
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

libcudacxx/include/cuda/std/__utility/pair.h

@@ -653,30 +653,6 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<1, pair<_T1, _T2>>
   using type _CCCL_NODEBUG_ALIAS = _T2;
 };
 
-#if _CCCL_HAS_HOST_STD_LIB()
-template <class _T1, class _T2>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::pair<_T1, _T2>> : public integral_constant<size_t, 2>
-{};
-
-template <size_t _Ip, class _T1, class _T2>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, ::std::pair<_T1, _T2>>
-{
-  static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
-};
-
-template <class _T1, class _T2>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<0, ::std::pair<_T1, _T2>>
-{
-  using type _CCCL_NODEBUG_ALIAS = _T1;
-};
-
-template <class _T1, class _T2>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<1, ::std::pair<_T1, _T2>>
-{
-  using type _CCCL_NODEBUG_ALIAS = _T2;
-};
-#endif // _CCCL_HAS_HOST_STD_LIB()
-
 template <size_t _Ip>
 struct __get_pair;
 

libcudacxx/include/cuda/std/array

@@ -452,19 +452,6 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, array<_Tp, _Size>>
   using type = _Tp;
 };
 
-#if _CCCL_HAS_HOST_STD_LIB()
-template <class _Tp, size_t _Size>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_size<::std::array<_Tp, _Size>> : public integral_constant<size_t, _Size>
-{};
-
-template <size_t _Ip, class _Tp, size_t _Size>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, ::std::array<_Tp, _Size>>
-{
-  static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
-  using type = _Tp;
-};
-#endif // _CCCL_HAS_HOST_STD_LIB()
-
 template <size_t _Ip, class _Tp, size_t _Size>
 [[nodiscard]] _CCCL_API constexpr _Tp& get(array<_Tp, _Size>& __a) noexcept
 {

libcudacxx/test/libcudacxx/cuda/utilities/tuple/std_types_tuple_element.pass.cpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the libcu++ Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: nvrtc
+
+#include <cuda/std/cassert>
+#include <cuda/std/tuple>
+
+#include <complex>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+template <class STD_TYPE, size_t Index, typename Expected>
+__host__ __device__ constexpr void test()
+{
+  static_assert(cuda::std::is_same_v<cuda::std::tuple_element_t<Index, STD_TYPE>, Expected>);
+  static_assert(cuda::std::is_same_v<cuda::std::tuple_element_t<Index, const STD_TYPE>, const Expected>);
+  static_assert(cuda::std::is_same_v<cuda::std::tuple_element_t<Index, volatile STD_TYPE>, volatile Expected>);
+  static_assert(
+    cuda::std::is_same_v<cuda::std::tuple_element_t<Index, const volatile STD_TYPE>, const volatile Expected>);
+}
+
+__host__ __device__ constexpr bool test()
+{
+  test<::std::pair<int, float>, 0, int>();
+  test<::std::pair<int, float>, 1, float>();
+
+  // tuple has the size of the number of template arguments
+  test<::std::tuple<int>, 0, int>();
+  test<::std::tuple<int, float>, 0, int>();
+  test<::std::tuple<int, float>, 1, float>();
+  test<::std::tuple<int, float, short>, 0, int>();
+  test<::std::tuple<int, float, short>, 1, float>();
+  test<::std::tuple<int, float, short>, 2, short>();
+
+  // array has always the same element
+  test<::std::array<int, 4>, 0, int>();
+  test<::std::array<int, 4>, 1, int>();
+  test<::std::array<int, 4>, 2, int>();
+  test<::std::array<int, 4>, 3, int>();
+
+  return true;
+}
+
+int main(int arg, char** argv)
+{
+  test();
+  static_assert(test());
+  return 0;
+}

libcudacxx/test/libcudacxx/cuda/utilities/tuple/std_types_tuple_size.pass.cpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the libcu++ Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: nvrtc
+
+#include <cuda/std/cassert>
+#include <cuda/std/tuple>
+
+#include <array>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+template <class STD_TYPE, size_t Size>
+__host__ __device__ constexpr void test()
+{
+  static_assert(cuda::std::tuple_size<STD_TYPE>::value == Size);
+  static_assert(cuda::std::tuple_size<const STD_TYPE>::value == Size);
+  static_assert(cuda::std::tuple_size<volatile STD_TYPE>::value == Size);
+  static_assert(cuda::std::tuple_size<const volatile STD_TYPE>::value == Size);
+}
+
+__host__ __device__ constexpr bool test()
+{
+  // pair always has a size of 2
+  test<::std::pair<int, float>, 2>();
+
+  // tuple has the size of the number of template arguments
+  test<::std::tuple<int>, 1>();
+  test<::std::tuple<int, int>, 2>();
+  test<::std::tuple<int, int, int>, 3>();
+
+  // array has the size of the number of elements
+  test<::std::array<int, 4>, 4>();
+  test<::std::array<int, 1337>, 1337>();
+
+  return true;
+}
+
+int main(int arg, char** argv)
+{
+  test();
+  static_assert(test());
+  return 0;
+}