Backport cuda::std::reference_wrapper C++20 features (#6709)

davebayer · web-flow · commit 48ff6376d2f2 · 2025-11-22T14:42:35.000Z
diff --git a/libcudacxx/include/cuda/std/__functional/reference_wrapper.h b/libcudacxx/include/cuda/std/__functional/reference_wrapper.h
@@ -41,33 +41,34 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT reference_wrapper : public __weak_result_typ
   using type = _Tp;
 
 private:
-  type* __f_;
+  type* __f_{};
 
-  static _CCCL_API inline void __fun(_Tp&) noexcept;
+  static _CCCL_API void __fun(_Tp&) noexcept;
   static void __fun(_Tp&&) = delete;
 
 public:
-  template <class _Up,
-            class = enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>()))>>
-  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper(_Up&& __u) noexcept(noexcept(__fun(declval<_Up>())))
+  template <
+    class _Up,
+    class = enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(::cuda::std::declval<_Up>()))>>
+  _CCCL_API constexpr reference_wrapper(_Up&& __u) noexcept(noexcept(__fun(::cuda::std::declval<_Up>())))
   {
     type& __f = static_cast<_Up&&>(__u);
     __f_      = ::cuda::std::addressof(__f);
   }
 
   // access
-  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 operator type&() const noexcept
+  _CCCL_API constexpr operator type&() const noexcept
   {
     return *__f_;
   }
-  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 type& get() const noexcept
+  [[nodiscard]] _CCCL_API constexpr type& get() const noexcept
   {
     return *__f_;
   }
 
   // invoke
   template <class... _ArgTypes>
-  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 invoke_result_t<type&, _ArgTypes...> operator()(_ArgTypes&&... __args) const
+  _CCCL_API constexpr invoke_result_t<type&, _ArgTypes...> operator()(_ArgTypes&&... __args) const
     noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)
   {
     return ::cuda::std::invoke(get(), ::cuda::std::forward<_ArgTypes>(__args)...);
@@ -78,25 +79,25 @@ template <class _Tp>
 _CCCL_HOST_DEVICE reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
 
 template <class _Tp>
-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<_Tp> ref(_Tp& __t) noexcept
+[[nodiscard]] _CCCL_API constexpr reference_wrapper<_Tp> ref(_Tp& __t) noexcept
 {
   return reference_wrapper<_Tp>(__t);
 }
 
 template <class _Tp>
-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept
+[[nodiscard]] _CCCL_API constexpr reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept
 {
   return __t;
 }
 
 template <class _Tp>
-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<const _Tp> cref(const _Tp& __t) noexcept
+[[nodiscard]] _CCCL_API constexpr reference_wrapper<const _Tp> cref(const _Tp& __t) noexcept
 {
   return reference_wrapper<const _Tp>(__t);
 }
 
 template <class _Tp>
-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<const _Tp> cref(reference_wrapper<_Tp> __t) noexcept
+[[nodiscard]] _CCCL_API constexpr reference_wrapper<const _Tp> cref(reference_wrapper<_Tp> __t) noexcept
 {
   return __t;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/func.bind_front/bind_front.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/func.bind_front/bind_front.pass.cpp
@@ -200,11 +200,9 @@ __host__ __device__ constexpr bool test()
     assert(h(2, 2, 2) == 9);
   }
 
-  // Make sure we don't treat cuda::std::reference_wrapper specially.
-#if TEST_STD_VER > 2017
-#  if TEST_COMPILER(NVRTC) // reference_wrapper requires `addressof` which is currently not supported with nvrtc
+#if TEST_COMPILER(NVRTC) // reference_wrapper requires `addressof` which is currently not supported with nvrtc
   if (!TEST_IS_CONSTANT_EVALUATED())
-#  endif // TEST_COMPILER(NVRTC)
+#endif // TEST_COMPILER(NVRTC)
   {
     auto add = [](cuda::std::reference_wrapper<int> a, cuda::std::reference_wrapper<int> b) {
       return a.get() + b.get();
@@ -213,7 +211,6 @@ __host__ __device__ constexpr bool test()
     auto f = cuda::std::bind_front(add, cuda::std::ref(i));
     assert(f(cuda::std::ref(j)) == 3);
   }
-#endif
 
   // Make sure we can call a function that's a pointer to a member function.
   {
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/func.invoke/invoke.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -203,8 +203,6 @@ __host__ __device__ void bullet_one_two_tests()
     test_b12<int volatile && (NonCopyable&&) volatile&&, int volatile&&>(cuda::std::move(cl));
     test_b12<int const volatile && (NonCopyable&&) const volatile&&, int const volatile&&>(cuda::std::move(cl));
   }
-#ifndef __cuda_std__
-  // uncomment when reenabling reference_wrapper
   {
     TestClass cl_obj(42);
     cuda::std::reference_wrapper<TestClass> cl(cl_obj);
@@ -231,7 +229,6 @@ __host__ __device__ void bullet_one_two_tests()
     test_b12<int volatile&(NonCopyable&&) volatile&, int volatile&>(cuda::std::move(cl));
     test_b12<int const volatile&(NonCopyable&&) const volatile&, int const volatile&>(cuda::std::move(cl));
   }
-#endif
   {
     TestClass cl_obj(42);
     TestClass* cl = &cl_obj;
@@ -278,8 +275,6 @@ __host__ __device__ void bullet_three_four_tests()
     test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
     test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
   }
-#ifndef __cuda_std__
-  // uncomment when reenabling reference_wrapper
   {
     typedef TestClass Fn;
     Fn cl(42);
@@ -296,7 +291,6 @@ __host__ __device__ void bullet_three_four_tests()
     test_b34<int volatile&>(cuda::std::reference_wrapper<Fn volatile>(cl));
     test_b34<int const volatile&>(cuda::std::reference_wrapper<Fn const volatile>(cl));
   }
-#endif
   {
     typedef TestClass Fn;
     Fn cl_obj(42);
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/binder_typedefs.compile.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/binder_typedefs.compile.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: c++03 || c++11 || c++14 || c++17
+// REQUIRES: c++17
 
 // ADDITIONAL_COMPILE_DEFINITIONS: CCCL_IGNORE_DEPRECATED_API
 
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/ctor.incomplete.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/ctor.incomplete.pass.cpp
@@ -7,13 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++17
-
 // <functional>
 //
 // reference_wrapper<T>
 //
-//  where T is an incomplete type (since C++20)
+//  where T is an incomplete type
 
 // #include <cuda/std/functional>
 #include <cuda/std/cassert>
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.pass.cpp
@@ -66,9 +66,7 @@ int main(int, char**)
   {
     using Ref = cuda::std::reference_wrapper<int>;
     static_assert(noexcept(Ref(nothrow_convertible<true>())));
-#if !TEST_COMPILER(NVHPC)
     static_assert(!noexcept(Ref(nothrow_convertible<false>())));
-#endif // !TEST_COMPILER(NVHPC)
   }
   {
     meow(0);
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.pass.cpp
@@ -43,18 +43,18 @@ struct A2
 
 __host__ __device__ void implicitly_convert(cuda::std::reference_wrapper<B>) noexcept;
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   {
     A1 a{};
-#if !TEST_COMPILER(NVHPC)
+#if !_CCCL_COMPILER(GCC, <, 8) && !(_CCCL_COMPILER(MSVC, <, 19, 40) && _CCCL_STD_VER < 2020)
     static_assert(!noexcept(implicitly_convert(a)));
-#endif // TEST_COMPILER(NVHPC)
+#endif // !_CCCL_COMPILER(GCC, <, 8) && !(_CCCL_COMPILER(MSVC, <, 19, 40) && _CCCL_STD_VER < 2020)
     cuda::std::reference_wrapper<B> b1 = a;
     assert(&b1.get() == &a.b_);
-#if !TEST_COMPILER(NVHPC)
+#if !_CCCL_COMPILER(GCC, <, 8) && !(_CCCL_COMPILER(MSVC, <, 19, 40) && _CCCL_STD_VER < 2020)
     static_assert(!noexcept(b1 = a));
-#endif // TEST_COMPILER(NVHPC)
+#endif // !_CCCL_COMPILER(GCC, <, 8) && !(_CCCL_COMPILER(MSVC, <, 19, 40) && _CCCL_STD_VER < 2020)
     b1 = a;
     assert(&b1.get() == &a.b_);
   }
@@ -73,9 +73,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref.incomplete.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref.incomplete.pass.cpp
@@ -7,15 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++17
-
 // <functional>
 //
 // reference_wrapper
 //
 // template <ObjectType T> reference_wrapper<const T> cref(const T& t);
 //
-//  where T is an incomplete type (since C++20)
+//  where T is an incomplete type
 
 // #include <cuda/std/functional>
 #include <cuda/std/cassert>
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   int i                                     = 0;
   cuda::std::reference_wrapper<const int> r = cuda::std::cref(i);
@@ -30,9 +30,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
@@ -26,7 +26,7 @@ struct A
 __host__ __device__ void cref(A) {}
 } // namespace adl
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   {
     const int i                                = 0;
@@ -46,9 +46,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/lwg3146.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/lwg3146.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   {
     int i = 0;
@@ -63,9 +63,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref.incomplete.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref.incomplete.pass.cpp
@@ -7,15 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++17
-
 // <functional>
 //
 // reference_wrapper
 //
 // template <ObjectType T> reference_wrapper<T> ref(T& t);
 //
-//  where T is an incomplete type (since C++20)
+//  where T is an incomplete type
 
 // #include <cuda/std/functional>
 #include <cuda/std/cassert>
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   int i                               = 0;
   cuda::std::reference_wrapper<int> r = cuda::std::ref(i);
@@ -30,9 +30,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
@@ -38,7 +38,7 @@ struct A
 __host__ __device__ void ref(A) {}
 } // namespace adl
 
-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
+__host__ __device__ constexpr bool test()
 {
   {
     int i                                = 0;
@@ -58,9 +58,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()
 int main(int, char**)
 {
   test();
-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
   static_assert(test());
-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)
 
   {
     unary_counting_predicate<bool (*)(int), int> cp(is5);
diff --git a/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.incomplete.compile.fail.cpp b/libcudacxx/test/libcudacxx/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.incomplete.compile.fail.cpp
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++17
-
 // <functional>
 //
 // reference_wrapper
@@ -17,7 +15,7 @@
 //  cuda::std::invoke_result_t<T&, ArgTypes...>
 //      operator()(ArgTypes&&... args) const;
 //
-// Requires T to be a complete type (since C++20).
+// Requires T to be a complete type
 
 // #include <cuda/std/functional>
 #include <cuda/std/utility>

Original file line number	Diff line number	Diff line change
`@@ -41,33 +41,34 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT reference_wrapper : public __weak_result_typ`
`41`	`41`	`using type = _Tp;`
`42`	`42`
`43`	`43`	`private:`
`44`		`- type* __f_;`
	`44`	`+ type* __f_{};`
`45`	`45`
`46`		`- static _CCCL_API inline void __fun(_Tp&) noexcept;`
	`46`	`+ static _CCCL_API void __fun(_Tp&) noexcept;`
`47`	`47`	`static void __fun(_Tp&&) = delete;`
`48`	`48`
`49`	`49`	`public:`
`50`		`- template <class _Up,`
`51`		`- class = enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>()))>>`
`52`		`- _CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper(_Up&& __u) noexcept(noexcept(__fun(declval<_Up>())))`
	`50`	`+ template <`
	`51`	`+ class _Up,`
	`52`	`+ class = enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(::cuda::std::declval<_Up>()))>>`
	`53`	`+ _CCCL_API constexpr reference_wrapper(_Up&& __u) noexcept(noexcept(__fun(::cuda::std::declval<_Up>())))`
`53`	`54`	`{`
`54`	`55`	`type& __f = static_cast<_Up&&>(__u);`
`55`	`56`	`__f_ = ::cuda::std::addressof(__f);`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`// access`
`59`		`- _CCCL_API inline _CCCL_CONSTEXPR_CXX20 operator type&() const noexcept`
	`60`	`+ _CCCL_API constexpr operator type&() const noexcept`
`60`	`61`	`{`
`61`	`62`	`return *__f_;`
`62`	`63`	`}`
`63`		`- _CCCL_API inline _CCCL_CONSTEXPR_CXX20 type& get() const noexcept`
	`64`	`+ [[nodiscard]] _CCCL_API constexpr type& get() const noexcept`
`64`	`65`	`{`
`65`	`66`	`return *__f_;`
`66`	`67`	`}`
`67`	`68`
`68`	`69`	`// invoke`
`69`	`70`	`template <class... _ArgTypes>`
`70`		`- _CCCL_API inline _CCCL_CONSTEXPR_CXX20 invoke_result_t<type&, _ArgTypes...> operator()(_ArgTypes&&... __args) const`
	`71`	`+ _CCCL_API constexpr invoke_result_t<type&, _ArgTypes...> operator()(_ArgTypes&&... __args) const`
`71`	`72`	`noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)`
`72`	`73`	`{`
`73`	`74`	`return ::cuda::std::invoke(get(), ::cuda::std::forward<_ArgTypes>(__args)...);`
`@@ -78,25 +79,25 @@ template <class _Tp>`
`78`	`79`	`_CCCL_HOST_DEVICE reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;`
`79`	`80`
`80`	`81`	`template <class _Tp>`
`81`		`-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<_Tp> ref(_Tp& __t) noexcept`
	`82`	`+[[nodiscard]] _CCCL_API constexpr reference_wrapper<_Tp> ref(_Tp& __t) noexcept`
`82`	`83`	`{`
`83`	`84`	`return reference_wrapper<_Tp>(__t);`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`template <class _Tp>`
`87`		`-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept`
	`88`	`+[[nodiscard]] _CCCL_API constexpr reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept`
`88`	`89`	`{`
`89`	`90`	`return __t;`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`template <class _Tp>`
`93`		`-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<const _Tp> cref(const _Tp& __t) noexcept`
	`94`	`+[[nodiscard]] _CCCL_API constexpr reference_wrapper<const _Tp> cref(const _Tp& __t) noexcept`
`94`	`95`	`{`
`95`	`96`	`return reference_wrapper<const _Tp>(__t);`
`96`	`97`	`}`
`97`	`98`
`98`	`99`	`template <class _Tp>`
`99`		`-_CCCL_API inline _CCCL_CONSTEXPR_CXX20 reference_wrapper<const _Tp> cref(reference_wrapper<_Tp> __t) noexcept`
	`100`	`+[[nodiscard]] _CCCL_API constexpr reference_wrapper<const _Tp> cref(reference_wrapper<_Tp> __t) noexcept`
`100`	`101`	`{`
`101`	`102`	`return __t;`
`102`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,11 +200,9 @@ __host__ __device__ constexpr bool test()`
`200`	`200`	`assert(h(2, 2, 2) == 9);`
`201`	`201`	`}`
`202`	`202`
`203`		`- // Make sure we don't treat cuda::std::reference_wrapper specially.`
`204`		`-#if TEST_STD_VER > 2017`
`205`		-# if TEST_COMPILER(NVRTC) // reference_wrapper requires `addressof` which is currently not supported with nvrtc
	`203`	+#if TEST_COMPILER(NVRTC) // reference_wrapper requires `addressof` which is currently not supported with nvrtc
`206`	`204`	`if (!TEST_IS_CONSTANT_EVALUATED())`
`207`		`-# endif // TEST_COMPILER(NVRTC)`
	`205`	`+#endif // TEST_COMPILER(NVRTC)`
`208`	`206`	`{`
`209`	`207`	`auto add = [](cuda::std::reference_wrapper<int> a, cuda::std::reference_wrapper<int> b) {`
`210`	`208`	`return a.get() + b.get();`
`@@ -213,7 +211,6 @@ __host__ __device__ constexpr bool test()`
`213`	`211`	`auto f = cuda::std::bind_front(add, cuda::std::ref(i));`
`214`	`212`	`assert(f(cuda::std::ref(j)) == 3);`
`215`	`213`	`}`
`216`		`-#endif`
`217`	`214`
`218`	`215`	`// Make sure we can call a function that's a pointer to a member function.`
`219`	`216`	`{`
Original file line number	Diff line number	Diff line change
`@@ -203,8 +203,6 @@ __host__ __device__ void bullet_one_two_tests()`
`203`	`203`	`test_b12<int volatile && (NonCopyable&&) volatile&&, int volatile&&>(cuda::std::move(cl));`
`204`	`204`	`test_b12<int const volatile && (NonCopyable&&) const volatile&&, int const volatile&&>(cuda::std::move(cl));`
`205`	`205`	`}`
`206`		`-#ifndef __cuda_std__`
`207`		`- // uncomment when reenabling reference_wrapper`
`208`	`206`	`{`
`209`	`207`	`TestClass cl_obj(42);`
`210`	`208`	`cuda::std::reference_wrapper<TestClass> cl(cl_obj);`
`@@ -231,7 +229,6 @@ __host__ __device__ void bullet_one_two_tests()`
`231`	`229`	`test_b12<int volatile&(NonCopyable&&) volatile&, int volatile&>(cuda::std::move(cl));`
`232`	`230`	`test_b12<int const volatile&(NonCopyable&&) const volatile&, int const volatile&>(cuda::std::move(cl));`
`233`	`231`	`}`
`234`		`-#endif`
`235`	`232`	`{`
`236`	`233`	`TestClass cl_obj(42);`
`237`	`234`	`TestClass* cl = &cl_obj;`
`@@ -278,8 +275,6 @@ __host__ __device__ void bullet_three_four_tests()`
`278`	`275`	`test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));`
`279`	`276`	`test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));`
`280`	`277`	`}`
`281`		`-#ifndef __cuda_std__`
`282`		`- // uncomment when reenabling reference_wrapper`
`283`	`278`	`{`
`284`	`279`	`typedef TestClass Fn;`
`285`	`280`	`Fn cl(42);`
`@@ -296,7 +291,6 @@ __host__ __device__ void bullet_three_four_tests()`
`296`	`291`	`test_b34<int volatile&>(cuda::std::reference_wrapper<Fn volatile>(cl));`
`297`	`292`	`test_b34<int const volatile&>(cuda::std::reference_wrapper<Fn const volatile>(cl));`
`298`	`293`	`}`
`299`		`-#endif`
`300`	`294`	`{`
`301`	`295`	`typedef TestClass Fn;`
`302`	`296`	`Fn cl_obj(42);`
Original file line number	Diff line number	Diff line change
`@@ -66,9 +66,7 @@ int main(int, char**)`
`66`	`66`	`{`
`67`	`67`	`using Ref = cuda::std::reference_wrapper<int>;`
`68`	`68`	`static_assert(noexcept(Ref(nothrow_convertible<true>())));`
`69`		`-#if !TEST_COMPILER(NVHPC)`
`70`	`69`	`static_assert(!noexcept(Ref(nothrow_convertible<false>())));`
`71`		`-#endif // !TEST_COMPILER(NVHPC)`
`72`	`70`	`}`
`73`	`71`	`{`
`74`	`72`	`meow(0);`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`
`20`	`20`	`#include "test_macros.h"`
`21`	`21`
`22`		`-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()`
	`22`	`+__host__ __device__ constexpr bool test()`
`23`	`23`	`{`
`24`	`24`	`int i = 0;`
`25`	`25`	`cuda::std::reference_wrapper<const int> r = cuda::std::cref(i);`
`@@ -30,9 +30,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()`
`30`	`30`	`int main(int, char**)`
`31`	`31`	`{`
`32`	`32`	`test();`
`33`		`-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)`
`34`	`33`	`static_assert(test());`
`35`		`-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)`
`36`	`34`
`37`	`35`	`return 0;`
`38`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ struct A`
`26`	`26`	`__host__ __device__ void cref(A) {}`
`27`	`27`	`} // namespace adl`
`28`	`28`
`29`		`-__host__ __device__ TEST_CONSTEXPR_CXX20 bool test()`
	`29`	`+__host__ __device__ constexpr bool test()`
`30`	`30`	`{`
`31`	`31`	`{`
`32`	`32`	`const int i = 0;`
`@@ -46,9 +46,7 @@ __host__ __device__ TEST_CONSTEXPR_CXX20 bool test()`
`46`	`46`	`int main(int, char**)`
`47`	`47`	`{`
`48`	`48`	`test();`
`49`		`-#if TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)`
`50`	`49`	`static_assert(test());`
`51`		`-#endif // TEST_STD_VER > 2017 && !TEST_COMPILER(NVRTC)`
`52`	`50`
`53`	`51`	`return 0;`
`54`	`52`	`}`