cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__tuple_dir/tuple_leaf.h

@@ -0,0 +1,452 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___TUPLE_TUPLE_LEAF_H
+#define _CUDA_STD___TUPLE_TUPLE_LEAF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__fwd/get.h>
+#include <cuda/std/__fwd/tuple.h>
+#include <cuda/std/__memory/allocator_arg_t.h>
+#include <cuda/std/__tuple_dir/make_tuple_types.h>
+#include <cuda/std/__tuple_dir/sfinae_helpers.h>
+#include <cuda/std/__tuple_dir/tuple_constraints.h>
+#include <cuda/std/__tuple_dir/tuple_element.h>
+#include <cuda/std/__tuple_dir/tuple_indices.h>
+#include <cuda/std/__tuple_dir/tuple_types.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_assignable.h>
+#include <cuda/std/__type_traits/is_empty.h>
+#include <cuda/std/__type_traits/is_final.h>
+#include <cuda/std/__type_traits/is_nothrow_assignable.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_swappable.h>
+#include <cuda/std/__type_traits/reference_constructs_from_temporary.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/swap.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+struct __tuple_leaf_default_constructor_tag
+{};
+
+//! @brief Different types of `__tuple_leaf` specialization. We need those to ensure we are trivially copyable
+enum class __tuple_leaf_specialization
+{
+  __default,
+  __synthesize_assignment,
+  __empty_non_final,
+};
+
+//! @brief Detects whether we need to synthesize the assignment operator for reference types or can use EBCO
+template <class _Tp>
+_CCCL_API constexpr __tuple_leaf_specialization __tuple_leaf_choose()
+{
+  return is_empty_v<_Tp> && !is_final_v<_Tp> ? __tuple_leaf_specialization::__empty_non_final
+       : __must_synthesize_assignment_v<_Tp>
+         ? __tuple_leaf_specialization::__synthesize_assignment
+         : __tuple_leaf_specialization::__default;
+}
+
+template <size_t _Ip, class _Hp, __tuple_leaf_specialization = __tuple_leaf_choose<_Hp>()>
+class __tuple_leaf;
+
+_CCCL_EXEC_CHECK_DISABLE
+template <size_t _Ip, class _Hp, __tuple_leaf_specialization _Ep>
+_CCCL_API inline void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x,
+                           __tuple_leaf<_Ip, _Hp, _Ep>& __y) noexcept(is_nothrow_swappable_v<_Hp>)
+{
+  swap(__x.get(), __y.get());
+}
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4244) // conversion from '_Tp' to '_Hp', possible loss of data
+
+template <class _Tp, class _Up, class _Current, bool = !is_same_v<remove_cvref_t<_Tp>, _Current>>
+inline constexpr bool __tuple_leaf_can_forward = false;
+
+template <class _Tp, class _Up, class _Current>
+inline constexpr bool __tuple_leaf_can_forward<_Tp, _Up, _Current, true> = is_constructible_v<_Up, _Tp>;
+
+template <size_t _Ip, class _Hp>
+class __tuple_leaf<_Ip, _Hp, __tuple_leaf_specialization::__default>
+{
+  _Hp __value_;
+
+#if defined(_CCCL_BUILTIN_REFERENCE_CONSTRUCTS_FROM_TEMPORARY)
+  template <class _Up>
+  static constexpr bool __can_bind_reference = !reference_constructs_from_temporary_v<_Hp&, _Up>;
+#else
+  template <class _Up>
+  static constexpr bool __can_bind_reference = true;
+#endif // !_CCCL_BUILTIN_REFERENCE_CONSTRUCTS_FROM_TEMPORARY
+
+public:
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf() noexcept(is_nothrow_default_constructible_v<_Hp>)
+      : __value_()
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf(__tuple_leaf_default_constructor_tag) noexcept(
+    is_nothrow_default_constructible_v<_Hp>)
+      : __value_()
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
+      : __value_()
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
+      : __value_(allocator_arg_t(), __a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
+      : __value_(__a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, enable_if_t<__tuple_leaf_can_forward<_Tp, _Hp, __tuple_leaf>, int> = 0>
+  _CCCL_API constexpr explicit __tuple_leaf(_Tp&& __t) noexcept(is_nothrow_constructible_v<_Hp, _Tp>)
+      : __value_(::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
+      : __value_(::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
+      : __value_(allocator_arg_t(), __a, ::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
+      : __value_(::cuda::std::forward<_Tp>(__t), __a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp>
+  _CCCL_API inline __tuple_leaf& operator=(_Tp&& __t) noexcept(is_nothrow_assignable_v<_Hp&, _Tp>)
+  {
+    __value_ = ::cuda::std::forward<_Tp>(__t);
+    return *this;
+  }
+
+  _CCCL_API inline void swap(__tuple_leaf& __t) noexcept(is_nothrow_swappable_v<_Hp>)
+  {
+    ::cuda::std::swap(*this, __t);
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Hp& get() noexcept
+  {
+    return __value_;
+  }
+  [[nodiscard]] _CCCL_API constexpr const _Hp& get() const noexcept
+  {
+    return __value_;
+  }
+};
+
+template <size_t _Ip, class _Hp>
+class __tuple_leaf<_Ip, _Hp, __tuple_leaf_specialization::__synthesize_assignment>
+{
+  _Hp __value_;
+
+#if defined(_CCCL_BUILTIN_REFERENCE_CONSTRUCTS_FROM_TEMPORARY)
+  template <class _Up>
+  static constexpr bool __can_bind_reference = !reference_constructs_from_temporary_v<_Hp&, _Up>;
+#else
+  template <class _Up>
+  static constexpr bool __can_bind_reference = true;
+#endif // !_CCCL_BUILTIN_REFERENCE_CONSTRUCTS_FROM_TEMPORARY
+
+public:
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf() noexcept(is_nothrow_default_constructible_v<_Hp>)
+      : __value_()
+  {
+    static_assert(!is_reference_v<_Hp>, "Attempted to default construct a reference element in a tuple");
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, enable_if_t<__tuple_leaf_can_forward<_Tp, _Hp, __tuple_leaf>, int> = 0>
+  _CCCL_API constexpr explicit __tuple_leaf(_Tp&& __t) noexcept(is_nothrow_constructible_v<_Hp, _Tp>)
+      : __value_(::cuda::std::forward<_Tp>(__t))
+  {
+    static_assert(__can_bind_reference<_Tp&&>,
+                  "Attempted construction of reference element "
+                  "binds to a temporary whose lifetime has ended");
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
+      : __value_(::cuda::std::forward<_Tp>(__t))
+  {
+    static_assert(__can_bind_reference<_Tp&&>,
+                  "Attempted construction of reference element binds to a "
+                  "temporary whose lifetime has ended");
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  __tuple_leaf(const __tuple_leaf& __t) = default;
+  _CCCL_EXEC_CHECK_DISABLE
+  __tuple_leaf(__tuple_leaf&& __t) = default;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf& operator=(const __tuple_leaf& __t) noexcept
+  {
+    __value_ = __t.__value_;
+    return *this;
+  }
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf& operator=(__tuple_leaf&& __t) noexcept
+  {
+    __value_ = ::cuda::std::move(__t.__value_);
+    return *this;
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp>
+  _CCCL_API inline __tuple_leaf& operator=(_Tp&& __t) noexcept(is_nothrow_assignable_v<_Hp&, _Tp>)
+  {
+    __value_ = ::cuda::std::forward<_Tp>(__t);
+    return *this;
+  }
+
+  _CCCL_API inline void swap(__tuple_leaf& __t) noexcept(is_nothrow_swappable_v<_Hp>)
+  {
+    ::cuda::std::swap(*this, __t);
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Hp& get() noexcept
+  {
+    return __value_;
+  }
+  [[nodiscard]] _CCCL_API constexpr const _Hp& get() const noexcept
+  {
+    return __value_;
+  }
+};
+
+template <size_t _Ip, class _Hp>
+class __tuple_leaf<_Ip, _Hp, __tuple_leaf_specialization::__empty_non_final> : private remove_const_t<_Hp>
+{
+public:
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf() noexcept(is_nothrow_default_constructible_v<_Hp>)
+      : _Hp()
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API constexpr __tuple_leaf(__tuple_leaf_default_constructor_tag) noexcept(
+    is_nothrow_default_constructible_v<_Hp>)
+      : _Hp()
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
+      : _Hp(allocator_arg_t(), __a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Alloc>
+  _CCCL_API inline __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
+      : _Hp(__a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, enable_if_t<__tuple_leaf_can_forward<_Tp, _Hp, __tuple_leaf>, int> = 0>
+  _CCCL_API constexpr explicit __tuple_leaf(_Tp&& __t) noexcept(is_nothrow_constructible_v<_Hp, _Tp>)
+      : _Hp(::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
+      : _Hp(::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
+      : _Hp(allocator_arg_t(), __a, ::cuda::std::forward<_Tp>(__t))
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, class _Alloc>
+  _CCCL_API inline explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
+      : _Hp(::cuda::std::forward<_Tp>(__t), __a)
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, enable_if_t<is_assignable_v<_Hp&, const _Tp&>, int> = 0>
+  _CCCL_API inline __tuple_leaf& operator=(const _Tp& __t) noexcept(is_nothrow_assignable_v<_Hp&, const _Tp&>)
+  {
+    _Hp::operator=(__t);
+    return *this;
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class _Tp, enable_if_t<is_assignable_v<_Hp&, _Tp>, int> = 0>
+  _CCCL_API inline __tuple_leaf& operator=(_Tp&& __t) noexcept(is_nothrow_assignable_v<_Hp&, _Tp>)
+  {
+    _Hp::operator=(::cuda::std::forward<_Tp>(__t));
+    return *this;
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_API inline void swap(__tuple_leaf& __t) noexcept(is_nothrow_swappable_v<_Hp>)
+  {
+    ::cuda::std::swap(*this, __t);
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Hp& get() noexcept
+  {
+    return static_cast<_Hp&>(*this);
+  }
+  [[nodiscard]] _CCCL_API constexpr const _Hp& get() const noexcept
+  {
+    return static_cast<const _Hp&>(*this);
+  }
+};
+
+_CCCL_DIAG_POP
+
+struct __tuple_variadic_constructor_tag
+{};
+
+// __tuple_impl
+
+template <class _Indx, class... _Tp>
+struct _CCCL_DECLSPEC_EMPTY_BASES __tuple_impl;
+
+template <size_t... _Indx, class... _Tp>
+struct _CCCL_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
+    : public __tuple_leaf<_Indx, _Tp>...
+    , public __tuple_impl_sfinae_helper<__tuple_impl<__tuple_indices<_Indx...>, _Tp...>,
+                                        __tuple_all_copy_assignable_v<_Tp...>,
+                                        __tuple_all_move_assignable_v<_Tp...>>
+{
+  using _Constraints = __tuple_constraints<_Tp...>;
+
+  _CCCL_API constexpr __tuple_impl() noexcept(_Constraints::__nothrow_default_constructible)
+      : __tuple_leaf<_Indx, _Tp>()...
+  {}
+
+  // Handle non-allocator, full initialization
+  // Old MSVC cannot handle the noexept specifier outside of template arguments
+  template <class... _Up,
+            class _Constraints = typename _Constraints::template __variadic_constraints<_Up...>,
+            enable_if_t<sizeof...(_Up) == sizeof...(_Tp), int> = 0>
+  _CCCL_API constexpr explicit __tuple_impl(__tuple_variadic_constructor_tag,
+                                            _Up&&... __u) noexcept(_Constraints::__nothrow_constructible)
+      : __tuple_leaf<_Indx, _Tp>(::cuda::std::forward<_Up>(__u))...
+  {}
+
+  // Handle non-allocator, partial default initialization
+  // Recursively delegate until we have full rank
+  template <class... _Up, enable_if_t<sizeof...(_Up) < sizeof...(_Tp), int> = 0>
+  _CCCL_API constexpr explicit __tuple_impl(__tuple_variadic_constructor_tag __tag, _Up&&... __u) noexcept(
+    noexcept(__tuple_impl(__tag, ::cuda::std::forward<_Up>(__u)..., __tuple_leaf_default_constructor_tag{})))
+      : __tuple_impl(__tag, ::cuda::std::forward<_Up>(__u)..., __tuple_leaf_default_constructor_tag{})
+  {}
+
+  // Handle allocator aware, full initialization
+  template <class _Alloc, class... _Up, enable_if_t<sizeof...(_Up) == sizeof...(_Tp), int> = 0>
+  _CCCL_API inline explicit __tuple_impl(
+    allocator_arg_t, const _Alloc& __a, __tuple_variadic_constructor_tag, _Up&&... __u)
+      : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, _Up>(), __a, ::cuda::std::forward<_Up>(__u))...
+  {}
+
+  // Handle allocator aware, full default initialization
+  template <class _Alloc>
+  _CCCL_API inline explicit __tuple_impl(allocator_arg_t, const _Alloc& __a)
+      : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc>(), __a)...
+  {}
+
+  template <class _Tuple, size_t _Indx2>
+  using __tuple_elem_at = tuple_element_t<_Indx2, __make_tuple_types_t<_Tuple>>;
+
+  // cannot use inline variable here
+  template <class _Tuple, enable_if_t<__tuple_constructible_struct<_Tuple, __tuple_types<_Tp...>>::value, int> = 0>
+  _CCCL_API constexpr __tuple_impl(_Tuple&& __t) noexcept(__tuple_nothrow_constructible<_Tuple, __tuple_types<_Tp...>>)
+      : __tuple_leaf<_Indx, _Tp>(::cuda::std::forward<__tuple_elem_at<_Tuple, _Indx>>(::cuda::std::get<_Indx>(__t)))...
+  {}
+
+  // cannot use inline variable here
+  template <class _Alloc,
+            class _Tuple,
+            enable_if_t<__tuple_constructible_struct<_Tuple, __tuple_types<_Tp...>>::value, int> = 0>
+  _CCCL_API inline __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
+      : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, __tuple_elem_at<_Tuple, _Indx>>(),
+                                 __a,
+                                 ::cuda::std::forward<__tuple_elem_at<_Tuple, _Indx>>(::cuda::std::get<_Indx>(__t)))...
+  {}
+
+  template <class _Tuple, enable_if_t<__tuple_assignable<_Tuple, __tuple_types<_Tp...>>, int> = 0>
+  _CCCL_API inline __tuple_impl&
+  operator=(_Tuple&& __t) noexcept(__tuple_nothrow_assignable<_Tuple, __tuple_types<_Tp...>>)
+  {
+    (__tuple_leaf<_Indx, _Tp>::operator=(
+       ::cuda::std::forward<__tuple_elem_at<_Tuple, _Indx>>(::cuda::std::get<_Indx>(__t))),
+     ...);
+    return *this;
+  }
+
+  _CCCL_HIDE_FROM_ABI __tuple_impl(const __tuple_impl&)            = default;
+  _CCCL_HIDE_FROM_ABI __tuple_impl(__tuple_impl&&)                 = default;
+  _CCCL_HIDE_FROM_ABI __tuple_impl& operator=(const __tuple_impl&) = default;
+  _CCCL_HIDE_FROM_ABI __tuple_impl& operator=(__tuple_impl&&)      = default;
+
+  // Using a fold exppression here breaks nvrtc
+  _CCCL_API inline void swap(__tuple_impl& __t) noexcept(__all<is_nothrow_swappable_v<_Tp>...>::value)
+  {
+    (__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t)), ...);
+  }
+};
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TUPLE_TUPLE_LEAF_H

cuda/cccl/headers/include/cuda/std/__tuple_dir/tuple_like.h

@@ -68,14 +68,13 @@ inline constexpr bool __tuple_like_impl<::cuda::std::ranges::subrange<_Ip, _Sp,
 template <class... _Tp>
 inline constexpr bool __tuple_like_impl<__tuple_types<_Tp...>> = true;
 
-#if _CCCL_STD_VER >= 2014
 template <class _Tp>
 _CCCL_CONCEPT __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>;
 
+// Not on line 74 because of __COUNTER__ missing in NVRTC
 template <class _Tp>
 _CCCL_CONCEPT __pair_like = _CCCL_REQUIRES_EXPR((_Tp)) //
   (requires(__tuple_like_impl<remove_cvref_t<_Tp>>), requires(tuple_size<remove_cvref_t<_Tp>>::value == 2));
-#endif // _CCCL_STD_VER >= 2014
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__type_traits/is_comparable.h

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___TYPE_TRAITS_IS_COMPARABLE_H
+#define _CUDA_STD___TYPE_TRAITS_IS_COMPARABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/boolean_testable.h>
+#include <cuda/std/__type_traits/make_const_lvalue_ref.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4389) // '==': signed/unsigned mismatch
+_CCCL_DIAG_SUPPRESS_MSVC(4018) // '<': signed/unsigned mismatch
+
+template <class _Tp, class _Up, class = void>
+inline constexpr bool __is_cpp17_equality_comparable_v = false;
+
+template <class _Tp, class _Up>
+inline constexpr bool __is_cpp17_equality_comparable_v<
+  _Tp,
+  _Up,
+  void_t<decltype(::cuda::std::declval<__make_const_lvalue_ref<_Tp>>()
+                  == ::cuda::std::declval<__make_const_lvalue_ref<_Up>>())>> =
+  __boolean_testable<decltype(::cuda::std::declval<__make_const_lvalue_ref<_Tp>>()
+                              == ::cuda::std::declval<__make_const_lvalue_ref<_Up>>())>;
+
+template <class _Tp, class _Up, bool = __is_cpp17_equality_comparable_v<_Tp, _Up>>
+inline constexpr bool __is_cpp17_nothrow_equality_comparable_v = false;
+
+template <class _Tp, class _Up>
+inline constexpr bool __is_cpp17_nothrow_equality_comparable_v<_Tp, _Up, true> = noexcept(
+  ::cuda::std::declval<__make_const_lvalue_ref<_Tp>>() == ::cuda::std::declval<__make_const_lvalue_ref<_Up>>());
+
+template <class _Tp, class _Up, class = void>
+inline constexpr bool __is_cpp17_less_than_comparable_v = false;
+
+template <class _Tp, class _Up>
+inline constexpr bool __is_cpp17_less_than_comparable_v<
+  _Tp,
+  _Up,
+  void_t<decltype(::cuda::std::declval<__make_const_lvalue_ref<_Tp>>()
+                  < ::cuda::std::declval<__make_const_lvalue_ref<_Up>>())>> =
+  __boolean_testable<decltype(::cuda::std::declval<__make_const_lvalue_ref<_Tp>>()
+                              < ::cuda::std::declval<__make_const_lvalue_ref<_Up>>())>;
+
+template <class _Tp, class _Up, bool = __is_cpp17_less_than_comparable_v<_Tp, _Up>>
+inline constexpr bool __is_cpp17_nothrow_less_than_comparable_v = false;
+
+template <class _Tp, class _Up>
+inline constexpr bool __is_cpp17_nothrow_less_than_comparable_v<_Tp, _Up, true> =
+  noexcept(::cuda::std::declval<__make_const_lvalue_ref<_Tp>>() < ::cuda::std::declval<__make_const_lvalue_ref<_Up>>());
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+_CCCL_DIAG_POP
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TYPE_TRAITS_IS_COMPARABLE_H

cuda/cccl/headers/include/cuda/std/__type_traits/is_convertible.h

@@ -77,10 +77,10 @@ inline constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = tru
 
 namespace __is_convertible_imp
 {
-
 _CCCL_DIAG_PUSH
 _CCCL_DIAG_SUPPRESS_NVHPC(volatile_func_param_deprecated)
 _CCCL_BEGIN_NV_DIAG_SUPPRESS(volatile_func_param_deprecated)
+_CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated-volatile")
 
 template <class _Tp>
 _CCCL_API inline void __test_convert(_Tp);

cuda/cccl/headers/include/cuda/std/__type_traits/is_fully_bounded_array.h

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___TYPE_TRAITS_IS_FULLY_BOUNDED_ARRAY_H
+#define _CUDA_STD___TYPE_TRAITS_IS_FULLY_BOUNDED_ARRAY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__cstddef/types.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Tp>
+inline constexpr bool __is_fully_bounded_array_helper_v = true;
+template <class _Tp>
+inline constexpr bool __is_fully_bounded_array_helper_v<_Tp[]> = false;
+template <class _Tp, size_t _Np>
+inline constexpr bool __is_fully_bounded_array_helper_v<_Tp[_Np]> = __is_fully_bounded_array_helper_v<_Tp>;
+
+//! @brief Trait to test if a type is a fully bounded array, for example T[1], or T[2][1][2], but not T or T[] or T[][2]
+template <class _Tp>
+inline constexpr bool __is_fully_bounded_array_v = false;
+template <class _Tp, size_t _Np>
+inline constexpr bool __is_fully_bounded_array_v<_Tp[_Np]> = __is_fully_bounded_array_helper_v<_Tp>;
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TYPE_TRAITS_IS_FULLY_BOUNDED_ARRAY_H

cuda/cccl/headers/include/cuda/std/__type_traits/is_swappable.h

@@ -66,7 +66,6 @@ struct __has_hidden_friend_swap
 
 namespace __detect_adl_swap
 {
-
 template <class _Tp>
 void swap(_Tp&, _Tp&) = delete;
 
@@ -147,7 +146,6 @@ struct __nothrow_swappable_with
 template <class _Tp, class _Up>
 struct __nothrow_swappable_with<_Tp, _Up, false> : false_type
 {};
-
 } // namespace __detail
 
 template <class _Tp>

cuda/cccl/headers/include/cuda/std/__utility/in_place.h

@@ -51,24 +51,14 @@ template <size_t _Idx>
 inline constexpr in_place_index_t<_Idx> in_place_index{};
 
 template <class _Tp>
-struct __is_inplace_type_imp : false_type
-{};
+inline constexpr bool __is_cuda_std_inplace_type_v = false;
 template <class _Tp>
-struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type
-{};
+inline constexpr bool __is_cuda_std_inplace_type_v<in_place_type_t<_Tp>> = true;
 
 template <class _Tp>
-using __is_inplace_type = __is_inplace_type_imp<remove_cvref_t<_Tp>>;
-
-template <class _Tp>
-struct __is_inplace_index_imp : false_type
-{};
+inline constexpr bool __is_cuda_std_inplace_index_v = false;
 template <size_t _Idx>
-struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type
-{};
-
-template <class _Tp>
-using __is_inplace_index = __is_inplace_index_imp<remove_cvref_t<_Tp>>;
+inline constexpr bool __is_cuda_std_inplace_index_v<in_place_index_t<_Idx>> = true;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 
@@ -89,16 +79,6 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT in_place_from_type_t
 template <class _Tp>
 inline constexpr in_place_from_type_t<_Tp> in_place_from_type{};
 
-template <class _Tp>
-struct __is_inplace_from_type_imp : ::cuda::std::false_type
-{};
-template <class _Tp>
-struct __is_inplace_from_type_imp<in_place_from_type_t<_Tp>> : ::cuda::std::true_type
-{};
-
-template <class _Tp>
-using __is_inplace_from_type = __is_inplace_from_type_imp<::cuda::std::remove_cvref_t<_Tp>>;
-
 _CCCL_END_NAMESPACE_CUDA
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__utility/integer_sequence.h

@@ -57,7 +57,6 @@ using __make_indices_imp _CCCL_NODEBUG_ALIAS =
 
 namespace __detail
 {
-
 template <typename _Tp, size_t... _Extra>
 struct __repeat;
 template <typename _Tp, _Tp... _Np, size_t... _Extra>
@@ -181,7 +180,6 @@ struct __parity<7>
       : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1>
   {};
 };
-
 } // namespace __detail
 
 template <size_t _Ep, size_t _Sp>