Modularize <utility>

.upstream-tests/test/std/utilities/function.objects/refwrap/binder_typedefs.compile.pass.cpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++03 || c++11 || c++14 || c++17
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCUDACXX_DISABLE_DEPRECATION_WARNINGS
+
+// <functional>
+
+// reference_wrapper
+
+// check that binder typedefs exit
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+#include <cuda/std/type_traits>
+
+struct UnaryFunction
+{
+    typedef long argument_type;
+    typedef char result_type;
+};
+
+struct BinaryFunction
+{
+    typedef int first_argument_type;
+    typedef char second_argument_type;
+    typedef long result_type;
+};
+
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<int(UnaryFunction::*)()>::result_type, int>::value, "");
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<int(UnaryFunction::*)()>::argument_type, UnaryFunction*>::value, "");
+
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<int(BinaryFunction::*)(char)>::result_type, int>::value, "");
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<int(BinaryFunction::*)(char)>::first_argument_type, BinaryFunction*>::value, "");
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<int(BinaryFunction::*)(char)>::second_argument_type, char>::value, "");
+
+static_assert(cuda::std::is_same<cuda::std::reference_wrapper<void(*)()>::result_type, void>::value, "");
+
+int main(int, char**)
+{
+  return 0;
+}

.upstream-tests/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// reference_wrapper
+
+// operator T& () const;
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+#include <cuda/std/cassert>
+
+#include "test_macros.h"
+
+class functor1
+{
+};
+
+template <class T>
+__host__ __device__ void
+test(T& t)
+{
+    cuda::std::reference_wrapper<T> r(t);
+    T& r2 = r;
+    assert(&r2 == &t);
+}
+
+__host__ __device__ void f() {}
+
+int main(int, char**)
+{
+    void (*fp)() = f;
+    test(fp);
+    test(f);
+    functor1 f1;
+    test(f1);
+    int i = 0;
+    test(i);
+    const int j = 0;
+    test(j);
+
+  return 0;
+}

.upstream-tests/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp

@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// reference_wrapper
+
+// reference_wrapper& operator=(const reference_wrapper<T>& x);
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+#include <cuda/std/cassert>
+
+#include "test_macros.h"
+
+class functor1
+{
+};
+
+struct convertible_to_int_ref {
+    int val = 0;
+    __host__ __device__ operator int&() { return val; }
+    __host__ __device__ operator int const&() const { return val; }
+};
+
+template <class T>
+__host__ __device__ void
+test(T& t)
+{
+    cuda::std::reference_wrapper<T> r(t);
+    T t2 = t;
+    cuda::std::reference_wrapper<T> r2(t2);
+    r2 = r;
+    assert(&r2.get() == &t);
+}
+
+__host__ __device__ void f() {}
+__host__ __device__ void g() {}
+
+__host__ __device__ void
+test_function()
+{
+    cuda::std::reference_wrapper<void ()> r(f);
+    cuda::std::reference_wrapper<void ()> r2(g);
+    r2 = r;
+    assert(&r2.get() == &f);
+}
+
+int main(int, char**)
+{
+    void (*fp)() = f;
+    test(fp);
+    test_function();
+    functor1 f1;
+    test(f1);
+    int i = 0;
+    test(i);
+    const int j = 0;
+    test(j);
+
+#if TEST_STD_VER >= 11
+    convertible_to_int_ref convi{};
+    test(convi);
+    convertible_to_int_ref const convic{};
+    test(convic);
+
+    {
+    using Ref = cuda::std::reference_wrapper<int>;
+    static_assert((cuda::std::is_assignable<Ref&, int&>::value), "");
+    static_assert((!cuda::std::is_assignable<Ref&, int>::value), "");
+    static_assert((!cuda::std::is_assignable<Ref&, int&&>::value), "");
+    }
+#endif
+
+  return 0;
+}

.upstream-tests/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// reference_wrapper
+
+// reference_wrapper(const reference_wrapper<T>& x);
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+#include <cuda/std/cassert>
+
+#include "test_macros.h"
+
+class functor1
+{
+};
+
+template <class T>
+__host__ __device__ void
+test(T& t)
+{
+    cuda::std::reference_wrapper<T> r(t);
+    cuda::std::reference_wrapper<T> r2 = r;
+    assert(&r2.get() == &t);
+}
+
+__host__ __device__ void f() {}
+
+int main(int, char**)
+{
+    void (*fp)() = f;
+    test(fp);
+    test(f);
+    functor1 f1;
+    test(f1);
+    int i = 0;
+    test(i);
+    const int j = 0;
+    test(j);
+
+  return 0;
+}

.upstream-tests/test/std/utilities/function.objects/refwrap/refwrap.const/ctor.incomplete.pass.cpp

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <functional>
+//
+// reference_wrapper<T>
+//
+//  where T is an incomplete type (since C++20)
+
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+#include <cuda/std/cassert>
+
+#include "test_macros.h"
+
+
+struct Foo;
+
+__host__ __device__ Foo& get_foo();
+
+__host__ __device__ void test() {
+    Foo& foo = get_foo();
+    cuda::std::reference_wrapper<Foo> ref{foo};
+    assert(&ref.get() == &foo);
+}
+
+struct Foo { };
+
+__host__ __device__ Foo& get_foo() {
+    static Foo foo;
+    return foo;
+}
+
+int main(int, char**) {
+    test();
+    return 0;
+}

.upstream-tests/test/std/utilities/function.objects/refwrap/refwrap.const/deduct.pass.cpp

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: gcc-7
+
+// <functional>
+
+// template <class T>
+//   reference_wrapper(T&) -> reference_wrapper<T>;
+
+// #include <cuda/std/functional>
+#include <cuda/std/utility>
+
+#pragma nv_diag_suppress set_but_not_used
+
+int main(int, char**) {
+    int i = 0;
+    cuda::std::reference_wrapper ri(i);
+    static_assert(cuda::std::is_same_v<decltype(ri), cuda::std::reference_wrapper<int>>);
+    cuda::std::reference_wrapper ri2(ri);
+    static_assert(cuda::std::is_same_v<decltype(ri2), cuda::std::reference_wrapper<int>>);
+    const int j = 0;
+    cuda::std::reference_wrapper rj(j);
+    static_assert(cuda::std::is_same_v<decltype(rj), cuda::std::reference_wrapper<const int>>);
+    cuda::std::reference_wrapper rj2(rj);
+    static_assert(cuda::std::is_same_v<decltype(rj2), cuda::std::reference_wrapper<const int>>);
+
+    return 0;
+}