Update tuple to C++20 (#9)

* Update to use c++20

* Fix constraints and clang-tidy warnings in the implementation

* Ignore/fix some of the tests with gcc or nvcc

* Fix the copyright notice in the extra tests

* Fix some unused variable warnings

* Fix nvcc host function called from host device function warnings

* Update the clang tidy and fix the new warnings

* misc changes
- fix more clang-tidy warnings
- revert the use of requires for cexa::get
- don't use std::reference_constructs_from_temporary, as support varies,
  especially for older compilers

* Use if defined instead of ifdef

* Remove an extra semicolon and some unused parameters

* Fix warnings and use sfinae for the tuple-like ctor

* Fix compilation with nvcc 12.2

* Remove the date from the copyright statement

* Remove a useless comment

Author: tretre91

tuple/.clang-tidy

@@ -26,12 +26,14 @@ Checks: >
   -cppcoreguidelines-narrowing-conversions,
   -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
   -cppcoreguidelines-pro-type-member-init,
   -cppcoreguidelines-pro-type-reinterpret-cast,
   google-*,
   -google-readability-todo,
+  -google-runtime-float,
   -google-runtime-int,
   hicpp-*,
   -hicpp-explicit-conversions,
@@ -48,7 +50,7 @@ Checks: >
   modernize-*,
   -modernize-pass-by-value,
   -modernize-use-auto,
-  -modernize-use-constraints,
+  -modernize-use-integer-sign-comparison,
   -modernize-use-nodiscard,
   -modernize-use-trailing-return-type,
   performance-*,
@@ -58,23 +60,20 @@ Checks: >
   -portability-avoid-pragma-once,
   -portability-template-virtual-member-function,
   readability-*,
-  -readability-else-after-return,
   -readability-function-cognitive-complexity,
-  -readability-identifier-naming,
   -readability-identifier-length,
   -readability-implicit-bool-conversion,
   -readability-magic-numbers,
   -readability-math-missing-parentheses,
   -readability-named-parameter,
   -readability-redundant-access-specifiers,
-  -readability-use-concise-preprocessor-directives,
-  -cert-oop54-cpp
+  -readability-use-concise-preprocessor-directives
 WarningsAsErrors: '*'
 CheckOptions:
   - key: cppcoreguidelines-rvalue-reference-param-not-moved.AllowPartialMove
     value: 'true'
   - key: readability-identifier-naming.ClassCase
-    value: CamelCase
+    value: lower_case
   - key: readability-identifier-naming.FunctionCase
     value: lower_case
   - key: readability-identifier-naming.FunctionIgnoredRegexp
@@ -88,8 +87,6 @@ CheckOptions:
   - key: readability-identifier-naming.PrivateMemberPrefix
     value: m_
   - key: readability-identifier-naming.StructCase
-    value: CamelCase
-  - key: readability-identifier-naming.StructIgnoredRegexp
-    value: '(is_.*|sum|prod|land|lor|band|bor|bxor|min|max|minmax|coordinate_of|chunk_traits|rebind|kwArgs_fft)'
+    value: lower_case
   - key: readability-identifier-naming.TemplateParameterCase
     value: CamelCase

tuple/CMakeLists.txt

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2026 CExA-project
+# SPDX-FileCopyrightText: Copyright (C) The CExA project
 # SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 cmake_minimum_required(VERSION 3.22)
 
@@ -28,6 +28,7 @@ add_library(cexa.tuple INTERFACE)
 # )
 target_include_directories(cexa.tuple INTERFACE "${CMAKE_CURRENT_LIST_DIR}/include")
 target_link_libraries(cexa.tuple INTERFACE Kokkos::kokkos)
+target_compile_features(cexa.tuple INTERFACE cxx_std_20)
 add_library(cexa::tuple ALIAS cexa.tuple)
 
 if(CEXA_TUPLE_ENABLE_TESTS)

tuple/README.md

@@ -1,5 +1,5 @@
 <!--
-SPDX-FileCopyrightText: 2026 CExA-project
+SPDX-FileCopyrightText: Copyright (C) The CExA project
 
 SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception
 -->

tuple/include/impl/apply.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2026 CExA-project
+// SPDX-FileCopyrightText: Copyright (C) The CExA project
 // SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 #pragma once
 
@@ -9,6 +9,10 @@
 #include "traits.hpp"
 #include "tuple.hpp"
 
+#if defined(CEXA_HAS_CXX23)
+#include <functional>
+#endif
+
 namespace cexa {
 
 namespace impl {
@@ -21,7 +25,7 @@ template <class C, class Pointed, class Object, class... Args>
 KOKKOS_INLINE_FUNCTION constexpr decltype(auto) invoke_ptr(Pointed C::* member,
                                                            Object&& object,
                                                            Args&&... args) {
-  using object_t            = remove_cvref_t<Object>;
+  using object_t            = std::remove_cvref_t<Object>;
   constexpr bool is_wrapped = is_reference_wrapper_v<object_t>;
   constexpr bool is_derived_object =
       std::is_same_v<C, object_t> || std::is_base_of_v<C, object_t>;
@@ -48,9 +52,11 @@ KOKKOS_INLINE_FUNCTION constexpr decltype(auto) invoke_ptr(Pointed C::* member,
   }
 }
 
+// f may be a host function
+CEXA_NVCC_HOST_DEVICE_CHECK_DISABLE
 template <class F, class... Args>
 KOKKOS_INLINE_FUNCTION constexpr decltype(auto) invoke(F&& f, Args&&... args) {
-  if constexpr (std::is_member_pointer_v<remove_cvref_t<F>>) {
+  if constexpr (std::is_member_pointer_v<std::remove_cvref_t<F>>) {
     return invoke_ptr(f, std::forward<Args>(args)...);
   } else {
     return (std::forward<F>(f))(std::forward<Args>(args)...);
@@ -63,13 +69,15 @@ KOKKOS_INLINE_FUNCTION constexpr decltype(auto) apply(
   return invoke(std::forward<F>(f), cexa::get<I>(std::forward<Tuple>(t))...);
 }
 
+// This might call a host only constructor
+CEXA_NVCC_HOST_DEVICE_CHECK_DISABLE
 template <class T, class Tuple, std::size_t... I>
 KOKKOS_INLINE_FUNCTION constexpr T make_from_tuple(Tuple&& t,
                                                    std::index_sequence<I...>) {
   return T(cexa::get<I>(std::forward<Tuple>(t))...);
 }
 
-template <class U, class T, std::size_t = tuple_size_v<impl::remove_cvref_t<T>>>
+template <class U, class T, std::size_t = tuple_size_v<std::remove_cvref_t<T>>>
 struct make_tuple_constraint : std::true_type {};
 
 template <class U, class Tuple>
@@ -78,7 +86,7 @@ struct make_tuple_constraint<U, Tuple, 1> {
       U, decltype(get<0>(std::declval<Tuple>()))>;
 };
 
-template <class T, class Tuple, class seq>
+template <class T, class Tuple, class Seq>
 struct is_constructible_from_tuple;
 
 template <class T, class Tuple, std::size_t... Ints>
@@ -91,28 +99,47 @@ template <class T, class Tuple>
 inline constexpr bool is_constructible_from_tuple_v =
     is_constructible_from_tuple<T, Tuple,
                                 std::make_index_sequence<tuple_size_v<
-                                    impl::remove_cvref_t<Tuple>>>>::value;
+                                    std::remove_cvref_t<Tuple>>>>::value;
+
+#if defined(CEXA_HAS_CXX23)
+template <class F, class Tuple, class Other>
+struct is_nothrow_applicable : std::false_type {};
+
+template <class F, class Tuple, std::size_t... Is>
+struct is_nothrow_applicable<F, Tuple, std::index_sequence<Is...>> {
+  static constexpr bool value = noexcept(
+      std::invoke(std::declval<F>(), get<Is>(std::declval<Tuple>())...));
+};
 
+template <class F, class Tuple>
+constexpr bool is_nothrow_applicable_v =
+    is_nothrow_applicable<F, Tuple,
+                          decltype(std::make_index_sequence<tuple_size_v<
+                                       std::remove_cvref_t<Tuple>>>{})>::value;
+#endif
 }  // namespace impl
 
 template <class F, class Tuple>
-KOKKOS_INLINE_FUNCTION constexpr decltype(auto) apply(F&& f, Tuple&& t) {
-  static_assert(impl::is_tuple_v<impl::remove_cvref_t<Tuple>>,
+KOKKOS_INLINE_FUNCTION constexpr decltype(auto) apply(F&& f, Tuple&& t)
+#if defined(CEXA_HAS_CXX23)
+    noexcept(impl::is_nothrow_applicable_v<F, Tuple>)
+#endif
+{
+  static_assert(impl::is_tuple_v<std::remove_cvref_t<Tuple>>,
                 "cexa::apply can only be called with cexa::tuple");
   return impl::apply(
       std::forward<F>(f), std::forward<Tuple>(t),
       std::make_index_sequence<tuple_size_v<std::remove_reference_t<Tuple>>>{});
 }
 
-template <
-    class T, class Tuple,
-    class = std::enable_if_t<impl::is_constructible_from_tuple_v<T, Tuple>>>
+template <class T, class Tuple>
+  requires impl::is_constructible_from_tuple_v<T, Tuple>
 KOKKOS_INLINE_FUNCTION constexpr T make_from_tuple(Tuple&& t) {
-  static_assert(impl::is_tuple_v<impl::remove_cvref_t<Tuple>>,
+  static_assert(impl::is_tuple_v<std::remove_cvref_t<Tuple>>,
                 "cexa::make_from_tuple can only be called with cexa::tuple");
   constexpr std::size_t size = tuple_size_v<std::remove_reference_t<Tuple>>;
   static_assert(
-      impl::make_tuple_constraint<T, impl::remove_cvref_t<Tuple>>::value);
+      impl::make_tuple_constraint<T, std::remove_cvref_t<Tuple>>::value);
   return impl::make_from_tuple<T>(std::forward<Tuple>(t),
                                   std::make_index_sequence<size>{});
 }

tuple/include/impl/creation.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2026 CExA-project
+// SPDX-FileCopyrightText: Copyright (C) The CExA project
 // SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 #pragma once
 
@@ -13,7 +13,7 @@ namespace cexa {
 
 // tuple.creation
 template <class... TTypes>
-KOKKOS_INLINE_FUNCTION constexpr tuple<impl::unwrap_ref_decay_t<TTypes>...>
+KOKKOS_INLINE_FUNCTION constexpr tuple<std::unwrap_ref_decay_t<TTypes>...>
 make_tuple(TTypes&&... t) {
   return {std::forward<TTypes>(t)...};
 }
@@ -66,18 +66,20 @@ struct cartesian_product
                                  std::remove_reference_t<Tuples>>::value>...> {
 };
 
+// We might call std::get depending on the types in Tuples
+CEXA_NVCC_HOST_DEVICE_CHECK_DISABLE
 template <class... Tuples, std::size_t... Ints1, std::size_t... Ints2>
 KOKKOS_FORCEINLINE_FUNCTION constexpr tuple<cexa::tuple_element_t<
     Ints1,
-    impl::remove_cvref_t<cexa::tuple_element_t<Ints2, tuple<Tuples...>>>>...>
+    std::remove_cvref_t<cexa::tuple_element_t<Ints2, tuple<Tuples...>>>>...>
 tuple_cat_impl(tuple<Tuples...>&& tuples, std::index_sequence<Ints1...>,
                std::index_sequence<Ints2...>) {
   return {get<Ints1>(std::move(get<Ints2>(tuples)))...};
 }
 }  // namespace impl
 
-template <class... Tuples,
-          class = std::enable_if_t<(impl::is_tuple_like<Tuples>::value && ...)>>
+template <class... Tuples>
+  requires(impl::is_tuple_like<Tuples>::value && ...)
 KOKKOS_INLINE_FUNCTION constexpr auto tuple_cat(Tuples&&... tuples) {
   using cartesian_product_t = impl::cartesian_product<Tuples...>;
   return impl::tuple_cat_impl(cexa::forward_as_tuple(tuples...),

tuple/include/impl/helper.hpp

@@ -1,13 +1,11 @@
-// SPDX-FileCopyrightText: 2026 CExA-project
+// SPDX-FileCopyrightText: Copyright (C) The CExA project
 // SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 #pragma once
 
 #include <array>
 #include <cstddef>
-#include <type_traits>  // integral_constant
-#if defined(CEXA_HAS_CXX20)
+#include <type_traits>
 #include <ranges>
-#endif
 
 #include "tuple_fwd.hpp"
 #include "traits.hpp"
@@ -65,7 +63,6 @@ struct tuple_element<I, std::array<T, N>> {
   using type = T;
 };
 
-#if defined(CEXA_HAS_CXX20)
 template <class I, class S, std::ranges::subrange_kind K>
 struct tuple_element<0, std::ranges::subrange<I, S, K>> {
   using type = I;
@@ -75,10 +72,9 @@ template <class I, class S, std::ranges::subrange_kind K>
 struct tuple_element<1, std::ranges::subrange<I, S, K>> {
   using type = S;
 };
-#endif
 
 template <std::size_t I, class T>
-using tuple_element_t = typename tuple_element<I, T>::type;
+using tuple_element_t = tuple_element<I, T>::type;
 
 // tuple_size
 template <class T>
@@ -108,24 +104,22 @@ struct tuple_size<std::pair<T, U>> : std::integral_constant<std::size_t, 2> {};
 template <class T, std::size_t N>
 struct tuple_size<std::array<T, N>> : std::integral_constant<std::size_t, N> {};
 
-#if defined(CEXA_HAS_CXX20)
 template <class I, class S, std::ranges::subrange_kind K>
 struct tuple_size<std::ranges::subrange<I, S, K>>
     : std::integral_constant<std::size_t, 2> {};
-#endif
 
 template <class T>
 inline constexpr std::size_t tuple_size_v = tuple_size<T>::value;
 }  // namespace cexa
 
 // NOTE: specializations of std::tuple_size and std::tuple_element for user
 // defined types are allowed.
-// NOLINTBEGIN(cert-dcl58-cpp)
+// NOLINTBEGIN(cert-dcl58-cpp,bugprone-std-namespace-modification)
 template <typename... Types>
 struct std::tuple_size<cexa::tuple<Types...>>
     : std::integral_constant<std::size_t, sizeof...(Types)> {};
 
 template <std::size_t I, typename... Types>
 struct std::tuple_element<I, cexa::tuple<Types...>>
     : cexa::tuple_element<I, cexa::tuple<Types...>> {};
-// NOLINTEND(cert-dcl58-cpp)
+// NOLINTEND(cert-dcl58-cpp,bugprone-std-namespace-modification)

tuple/include/impl/ignore.hpp

@@ -1,23 +1,13 @@
-// SPDX-FileCopyrightText: 2026 CExA-project
+// SPDX-FileCopyrightText: Copyright (C) The CExA project
 // SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 #pragma once
 
-#include "macros.hpp"
 #include <Kokkos_Macros.hpp>
 
 namespace cexa {
 namespace impl {
-// FIXME: address this
-// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 struct ignore_t {
-  KOKKOS_DEFAULTED_FUNCTION constexpr ignore_t() = default;
-  KOKKOS_DEFAULTED_FUNCTION
-#if defined(CEXA_HAS_CXX20)
-  constexpr
-#endif
-      ~ignore_t() = default;
-
-  template <typename T>
+  template <class T>
   KOKKOS_INLINE_FUNCTION constexpr const ignore_t& operator=(
       const T&) const noexcept {
     return *this;

tuple/include/impl/macros.hpp

@@ -1,16 +1,28 @@
-// SPDX-FileCopyrightText: 2026 CExA-project
+// SPDX-FileCopyrightText: Copyright (C) The CExA project
 // SPDX-License-Identifier: MIT or Apache-2.0 with LLVM-exception
 #pragma once
 
+#include <Kokkos_Macros.hpp>
+
 #if defined(_MSVC_LANG)
 #define CEXA_STD_VERSION _MSVC_LANG
 #else
 #define CEXA_STD_VERSION __cplusplus
 #endif
 
-#if CEXA_STD_VERSION >= 202002L
-#define CEXA_HAS_CXX20
-#endif
-#if CEXA_STD_VERSION >= 202302L
+// GCC 13 defines __cplusplus to 202100L when in c++23
+#if (defined(KOKKOS_COMPILER_GNU) && CEXA_STD_VERSION >= 202100L) || \
+    CEXA_STD_VERSION >= 202302L
 #define CEXA_HAS_CXX23
 #endif
+
+#if defined(KOKKOS_COMPILER_NVCC)
+#define CEXA_NVCC_HOST_DEVICE_CHECK_DISABLE _Pragma("nv_exec_check_disable")
+#else
+#define CEXA_NVCC_HOST_DEVICE_CHECK_DISABLE
+#endif
+
+// FIXME: As of cuda 13, support for operator<=> in device code is still brittle
+#if !defined(KOKKOS_COMPILER_NVCC)
+#define CEXA_TUPLE_IMPL_USE_SPACESHIP_OPERATOR
+#endif