[libcxx] adds std::identity to <functional>

Implements parts of:
    - P0898R3 Standard Library Concepts

Differential Revision: https://reviews.llvm.org/D98151

libcxx/include/functional

@@ -189,6 +189,8 @@ struct bit_not : unary_function<T, T>
     T operator()(const T& x) const;
 };
 
+struct identity; // C++20
+
 template <class Predicate>
 class unary_negate // deprecated in C++17
     : public unary_function<typename Predicate::argument_type, bool>
@@ -3215,6 +3217,19 @@ template <class _Tp>
 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
 #endif // > C++17
 
+#if _LIBCPP_STD_VER > 17
+// [func.identity]
+struct identity {
+    template<class _Tp>
+    constexpr _Tp&& operator()(_Tp&& __t) const noexcept
+    {
+        return _VSTD::forward<_Tp>(__t);
+    }
+
+    using is_transparent = void;
+};
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL

libcxx/test/std/utilities/function.objects/func.identity/identity.pass.cpp

@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// struct identity;
+
+#include <functional>
+
+#include <cassert>
+#include <concepts>
+
+#include "MoveOnly.h"
+
+static_assert(std::semiregular<std::identity>);
+static_assert(requires { typename std::identity::is_transparent; });
+
+constexpr bool test() {
+  std::identity id;
+  int i = 42;
+  assert(id(i) == 42);
+  assert(id(std::move(i)) == 42);
+
+  MoveOnly m1 = 2;
+  MoveOnly m2 = id(std::move(m1));
+  assert(m2.get() == 2);
+
+  assert(&id(i) == &i);
+  static_assert(&id(id) == &id);
+
+  const std::identity idc;
+  assert(idc(1) == 1);
+  assert(std::move(id)(1) == 1);
+  assert(std::move(idc)(1) == 1);
+
+  id = idc; // run-time checks assignment
+  static_assert(std::is_same_v<decltype(id(i)), int&>);
+  static_assert(std::is_same_v<decltype(id(std::declval<int&&>())), int&&>);
+  static_assert(
+      std::is_same_v<decltype(id(std::declval<int const&>())), int const&>);
+  static_assert(
+      std::is_same_v<decltype(id(std::declval<int const&&>())), int const&&>);
+  static_assert(std::is_same_v<decltype(id(std::declval<int volatile&>())),
+                               int volatile&>);
+  static_assert(std::is_same_v<decltype(id(std::declval<int volatile&&>())),
+                               int volatile&&>);
+  static_assert(
+      std::is_same_v<decltype(id(std::declval<int const volatile&>())),
+                     int const volatile&>);
+  static_assert(
+      std::is_same_v<decltype(id(std::declval<int const volatile&&>())),
+                     int const volatile&&>);
+
+  struct S {
+    constexpr S() = default;
+    constexpr S(S&&) noexcept(false) {}
+    constexpr S(S const&) noexcept(false) {}
+  };
+  S x;
+  static_assert(noexcept(id(x)));
+  static_assert(noexcept(id(S())));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}