Fix libcu++ compilation with clang-20 (#5799)

davebayer · web-flow · commit 70e770396d08 · 2025-09-08T14:34:50.000+02:00
diff --git a/libcudacxx/include/cuda/__utility/__basic_any/basic_any_ref.h b/libcudacxx/include/cuda/__utility/__basic_any/basic_any_ref.h
@@ -50,7 +50,7 @@ _CCCL_BEGIN_NAMESPACE_CUDA
 //! Note: a `__basic_any<__ireference<_Interface>> &&` is an rvalue reference,
 //! whereas a `__basic_any<_Interface &> &&` is an lvalue reference.
 template <class _Interface>
-struct __ireference : _Interface
+struct __ireference : ::cuda::std::remove_const_t<_Interface>
 {
   static_assert(::cuda::std::is_class_v<_Interface>, "expected a class type");
   static constexpr size_t __size_      = sizeof(void*);
diff --git a/libcudacxx/include/cuda/std/detail/libcxx/include/tuple b/libcudacxx/include/cuda/std/detail/libcxx/include/tuple
@@ -171,6 +171,7 @@ template <class... Types>
 #include <cuda/std/__type_traits/copy_cvref.h>
 #include <cuda/std/__type_traits/maybe_const.h>
 #include <cuda/std/__type_traits/reference_constructs_from_temporary.h>
+#include <cuda/std/__type_traits/remove_const.h>
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/integer_sequence.h>
 #include <cuda/std/__utility/move.h>
@@ -414,7 +415,7 @@ public:
 };
 
 template <size_t _Ip, class _Hp>
-class __tuple_leaf<_Ip, _Hp, __tuple_leaf_specialization::__empty_non_final> : private _Hp
+class __tuple_leaf<_Ip, _Hp, __tuple_leaf_specialization::__empty_non_final> : private remove_const_t<_Hp>
 {
 public:
   _CCCL_EXEC_CHECK_DISABLE
diff --git a/libcudacxx/test/libcudacxx/std/strings/string.view/string.view.cons/from_range.pass.cpp b/libcudacxx/test/libcudacxx/std/strings/string.view/string.view.cons/from_range.pass.cpp
@@ -28,17 +28,17 @@
 template <class CharT>
 struct TestBase
 {
-  __host__ __device__ static constexpr const CharT* range_data()
+  __host__ __device__ constexpr const CharT* range_data() const
   {
-    return TEST_STRLIT(CharT, "range_data");
+    return range_data_;
   }
-  __host__ __device__ static constexpr cuda::std::size_t range_size()
+  __host__ __device__ constexpr cuda::std::size_t range_size() const
   {
     return cuda::std::char_traits<CharT>::length(range_data());
   }
-  __host__ __device__ static constexpr const CharT* conv_data()
+  __host__ __device__ constexpr const CharT* conv_data() const
   {
-    return TEST_STRLIT(CharT, "conv_data");
+    return conv_data_;
   }
 
   __host__ __device__ constexpr const CharT* begin() const
@@ -49,6 +49,9 @@ struct TestBase
   {
     return range_data() + range_size();
   }
+
+  const CharT* range_data_;
+  const CharT* conv_data_;
 };
 
 template <class CharT>
@@ -57,6 +60,9 @@ __host__ __device__ constexpr void test_from_range()
   using SV = cuda::std::basic_string_view<CharT>;
   using TB = TestBase<CharT>;
 
+  const auto range_data = TEST_STRLIT(CharT, "range_data");
+  const auto conv_data  = TEST_STRLIT(CharT, "conv_data");
+
   // 1. test construction from cuda::std::array
   {
     cuda::std::array<CharT, 3> arr{TEST_CHARLIT(CharT, 'f'), TEST_CHARLIT(CharT, 'o'), TEST_CHARLIT(CharT, 'o')};
@@ -80,9 +86,9 @@ __host__ __device__ constexpr void test_from_range()
     static_assert(cuda::std::is_constructible_v<SV, NonConstConversionOperator>);
     static_assert(!cuda::std::is_convertible_v<const NonConstConversionOperator&, SV>);
 
-    NonConstConversionOperator nc{};
+    NonConstConversionOperator nc{range_data, conv_data};
     SV sv = nc;
-    assert(sv == TB::conv_data());
+    assert(sv == nc.conv_data());
   }
 
   // 3. test construction from a type with a const conversion operator
@@ -99,14 +105,14 @@ __host__ __device__ constexpr void test_from_range()
     static_assert(cuda::std::is_constructible_v<SV, const ConstConversionOperator&>);
 
     {
-      ConstConversionOperator cv{};
+      ConstConversionOperator cv{range_data, conv_data};
       SV sv = cv;
-      assert(sv == TB::conv_data());
+      assert(sv == cv.conv_data());
     }
     {
-      const ConstConversionOperator cv{};
+      const ConstConversionOperator cv{range_data, conv_data};
       SV sv = cv;
-      assert(sv == TB::conv_data());
+      assert(sv == cv.conv_data());
     }
   }
 
@@ -125,14 +131,14 @@ __host__ __device__ constexpr void test_from_range()
     static_assert(cuda::std::is_constructible_v<SV, const DeletedConversionOperator>);
 
     {
-      DeletedConversionOperator cv{};
+      DeletedConversionOperator cv{range_data, conv_data};
       SV sv = SV(cv);
-      assert(sv == TB::range_data());
+      assert(sv == cv.range_data());
     }
     {
-      const DeletedConversionOperator cv{};
+      const DeletedConversionOperator cv{range_data, conv_data};
       SV sv = SV(cv);
-      assert(sv == TB::range_data());
+      assert(sv == cv.range_data());
     }
   }
 
@@ -151,14 +157,14 @@ __host__ __device__ constexpr void test_from_range()
     static_assert(cuda::std::is_constructible_v<SV, const DeletedConstConversionOperator>);
 
     {
-      DeletedConstConversionOperator cv{};
+      DeletedConstConversionOperator cv{range_data, conv_data};
       SV sv = SV(cv);
-      assert(sv == TB::range_data());
+      assert(sv == cv.range_data());
     }
     {
-      const DeletedConstConversionOperator cv{};
+      const DeletedConstConversionOperator cv{range_data, conv_data};
       SV sv = SV(cv);
-      assert(sv == TB::range_data());
+      assert(sv == cv.range_data());
     }
   }
 
diff --git a/libcudacxx/test/libcudacxx/std/strings/string.view/string.view.deduct/range.pass.cpp b/libcudacxx/test/libcudacxx/std/strings/string.view/string.view.deduct/range.pass.cpp
@@ -38,9 +38,9 @@ __host__ __device__ constexpr void test_range_deduct()
   {
     struct Widget
     {
-      __host__ __device__ static constexpr const CharT* data()
+      __host__ __device__ constexpr const CharT* data() const
       {
-        return TEST_STRLIT(CharT, "foo");
+        return data_;
       }
       __host__ __device__ constexpr contiguous_iterator<const CharT*> begin() const
       {
@@ -50,11 +50,14 @@ __host__ __device__ constexpr void test_range_deduct()
       {
         return contiguous_iterator<const CharT*>(data() + 3);
       }
+
+      const CharT* data_;
     };
-    cuda::std::basic_string_view bsv = cuda::std::basic_string_view(Widget());
+    const auto widget_data           = TEST_STRLIT(CharT, "foo");
+    cuda::std::basic_string_view bsv = cuda::std::basic_string_view(Widget{widget_data});
     static_assert(cuda::std::is_same_v<decltype(bsv), cuda::std::basic_string_view<CharT>>);
     assert(bsv.size() == 3);
-    assert(bsv.data() == Widget::data());
+    assert(bsv.data() == widget_data);
   }
 }
 
diff --git a/libcudacxx/test/support/literal.h b/libcudacxx/test/support/literal.h
@@ -241,6 +241,13 @@ _test_int_literal_impl(const char (&cs)[N]) noexcept
 namespace test_integer_literals
 {
 
+// nvcc passes operator""_x to the host compiler as operator "" _x, which was deprecated in CWG 2521 (nvbug 5507437)
+// clang 20 already warns about this, so we need to suppress the warning here
+_CCCL_DIAG_PUSH
+#if _CCCL_COMPILER(CLANG, >=, 20)
+_CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated-literal-operator")
+#endif // _CCCL_COMPILER(CLANG, >=, 20)
+
 #if _CCCL_HAS_INT128()
 template <char... Cs>
 [[nodiscard]] __host__ __device__ constexpr __int128_t operator""_i128() noexcept
@@ -263,6 +270,8 @@ template <char... Cs>
 }
 #endif // _CCCL_HAS_INT128()
 
+_CCCL_DIAG_POP
+
 } // namespace test_integer_literals
 
 #endif // TEST_SUPPORT_LITERAL_H

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ _CCCL_BEGIN_NAMESPACE_CUDA`
`50`	`50`	//! Note: a `__basic_any<__ireference<_Interface>> &&` is an rvalue reference,
`51`	`51`	//! whereas a `__basic_any<_Interface &> &&` is an lvalue reference.
`52`	`52`	`template <class _Interface>`
`53`		`-struct __ireference : _Interface`
	`53`	`+struct __ireference : ::cuda::std::remove_const_t<_Interface>`
`54`	`54`	`{`
`55`	`55`	`static_assert(::cuda::std::is_class_v<_Interface>, "expected a class type");`
`56`	`56`	`static constexpr size_t __size_ = sizeof(void*);`
Original file line number	Diff line number	Diff line change
`@@ -28,17 +28,17 @@`
`28`	`28`	`template <class CharT>`
`29`	`29`	`struct TestBase`
`30`	`30`	`{`
`31`		`- __host__ __device__ static constexpr const CharT* range_data()`
	`31`	`+ __host__ __device__ constexpr const CharT* range_data() const`
`32`	`32`	`{`
`33`		`- return TEST_STRLIT(CharT, "range_data");`
	`33`	`+ return range_data_;`
`34`	`34`	`}`
`35`		`- __host__ __device__ static constexpr cuda::std::size_t range_size()`
	`35`	`+ __host__ __device__ constexpr cuda::std::size_t range_size() const`
`36`	`36`	`{`
`37`	`37`	`return cuda::std::char_traits<CharT>::length(range_data());`
`38`	`38`	`}`
`39`		`- __host__ __device__ static constexpr const CharT* conv_data()`
	`39`	`+ __host__ __device__ constexpr const CharT* conv_data() const`
`40`	`40`	`{`
`41`		`- return TEST_STRLIT(CharT, "conv_data");`
	`41`	`+ return conv_data_;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`__host__ __device__ constexpr const CharT* begin() const`
`@@ -49,6 +49,9 @@ struct TestBase`
`49`	`49`	`{`
`50`	`50`	`return range_data() + range_size();`
`51`	`51`	`}`
	`52`	`+`
	`53`	`+ const CharT* range_data_;`
	`54`	`+ const CharT* conv_data_;`
`52`	`55`	`};`
`53`	`56`
`54`	`57`	`template <class CharT>`
`@@ -57,6 +60,9 @@ __host__ __device__ constexpr void test_from_range()`
`57`	`60`	`using SV = cuda::std::basic_string_view<CharT>;`
`58`	`61`	`using TB = TestBase<CharT>;`
`59`	`62`
	`63`	`+ const auto range_data = TEST_STRLIT(CharT, "range_data");`
	`64`	`+ const auto conv_data = TEST_STRLIT(CharT, "conv_data");`
	`65`	`+`
`60`	`66`	`// 1. test construction from cuda::std::array`
`61`	`67`	`{`
`62`	`68`	`cuda::std::array<CharT, 3> arr{TEST_CHARLIT(CharT, 'f'), TEST_CHARLIT(CharT, 'o'), TEST_CHARLIT(CharT, 'o')};`
`@@ -80,9 +86,9 @@ __host__ __device__ constexpr void test_from_range()`
`80`	`86`	`static_assert(cuda::std::is_constructible_v<SV, NonConstConversionOperator>);`
`81`	`87`	`static_assert(!cuda::std::is_convertible_v<const NonConstConversionOperator&, SV>);`
`82`	`88`
`83`		`- NonConstConversionOperator nc{};`
	`89`	`+ NonConstConversionOperator nc{range_data, conv_data};`
`84`	`90`	`SV sv = nc;`
`85`		`- assert(sv == TB::conv_data());`
	`91`	`+ assert(sv == nc.conv_data());`
`86`	`92`	`}`
`87`	`93`
`88`	`94`	`// 3. test construction from a type with a const conversion operator`
`@@ -99,14 +105,14 @@ __host__ __device__ constexpr void test_from_range()`
`99`	`105`	`static_assert(cuda::std::is_constructible_v<SV, const ConstConversionOperator&>);`
`100`	`106`
`101`	`107`	`{`
`102`		`- ConstConversionOperator cv{};`
	`108`	`+ ConstConversionOperator cv{range_data, conv_data};`
`103`	`109`	`SV sv = cv;`
`104`		`- assert(sv == TB::conv_data());`
	`110`	`+ assert(sv == cv.conv_data());`
`105`	`111`	`}`
`106`	`112`	`{`
`107`		`- const ConstConversionOperator cv{};`
	`113`	`+ const ConstConversionOperator cv{range_data, conv_data};`
`108`	`114`	`SV sv = cv;`
`109`		`- assert(sv == TB::conv_data());`
	`115`	`+ assert(sv == cv.conv_data());`
`110`	`116`	`}`
`111`	`117`	`}`
`112`	`118`
`@@ -125,14 +131,14 @@ __host__ __device__ constexpr void test_from_range()`
`125`	`131`	`static_assert(cuda::std::is_constructible_v<SV, const DeletedConversionOperator>);`
`126`	`132`
`127`	`133`	`{`
`128`		`- DeletedConversionOperator cv{};`
	`134`	`+ DeletedConversionOperator cv{range_data, conv_data};`
`129`	`135`	`SV sv = SV(cv);`
`130`		`- assert(sv == TB::range_data());`
	`136`	`+ assert(sv == cv.range_data());`
`131`	`137`	`}`
`132`	`138`	`{`
`133`		`- const DeletedConversionOperator cv{};`
	`139`	`+ const DeletedConversionOperator cv{range_data, conv_data};`
`134`	`140`	`SV sv = SV(cv);`
`135`		`- assert(sv == TB::range_data());`
	`141`	`+ assert(sv == cv.range_data());`
`136`	`142`	`}`
`137`	`143`	`}`
`138`	`144`
`@@ -151,14 +157,14 @@ __host__ __device__ constexpr void test_from_range()`
`151`	`157`	`static_assert(cuda::std::is_constructible_v<SV, const DeletedConstConversionOperator>);`
`152`	`158`
`153`	`159`	`{`
`154`		`- DeletedConstConversionOperator cv{};`
	`160`	`+ DeletedConstConversionOperator cv{range_data, conv_data};`
`155`	`161`	`SV sv = SV(cv);`
`156`		`- assert(sv == TB::range_data());`
	`162`	`+ assert(sv == cv.range_data());`
`157`	`163`	`}`
`158`	`164`	`{`
`159`		`- const DeletedConstConversionOperator cv{};`
	`165`	`+ const DeletedConstConversionOperator cv{range_data, conv_data};`
`160`	`166`	`SV sv = SV(cv);`
`161`		`- assert(sv == TB::range_data());`
	`167`	`+ assert(sv == cv.range_data());`
`162`	`168`	`}`
`163`	`169`	`}`
`164`	`170`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,9 @@ __host__ __device__ constexpr void test_range_deduct()`
`38`	`38`	`{`
`39`	`39`	`struct Widget`
`40`	`40`	`{`
`41`		`- __host__ __device__ static constexpr const CharT* data()`
	`41`	`+ __host__ __device__ constexpr const CharT* data() const`
`42`	`42`	`{`
`43`		`- return TEST_STRLIT(CharT, "foo");`
	`43`	`+ return data_;`
`44`	`44`	`}`
`45`	`45`	`__host__ __device__ constexpr contiguous_iterator<const CharT*> begin() const`
`46`	`46`	`{`
`@@ -50,11 +50,14 @@ __host__ __device__ constexpr void test_range_deduct()`
`50`	`50`	`{`
`51`	`51`	`return contiguous_iterator<const CharT*>(data() + 3);`
`52`	`52`	`}`
	`53`	`+`
	`54`	`+ const CharT* data_;`
`53`	`55`	`};`
`54`		`- cuda::std::basic_string_view bsv = cuda::std::basic_string_view(Widget());`
	`56`	`+ const auto widget_data = TEST_STRLIT(CharT, "foo");`
	`57`	`+ cuda::std::basic_string_view bsv = cuda::std::basic_string_view(Widget{widget_data});`
`55`	`58`	`static_assert(cuda::std::is_same_v<decltype(bsv), cuda::std::basic_string_view<CharT>>);`
`56`	`59`	`assert(bsv.size() == 3);`
`57`		`- assert(bsv.data() == Widget::data());`
	`60`	`+ assert(bsv.data() == widget_data);`
`58`	`61`	`}`
`59`	`62`	`}`
`60`	`63`