libstdc++: Define std::invoke_r for C++23 (P2136R3)

We already supported this feature as std::__invoke<R>, for internal use.
This just adds a public version of it to <functional>.

Internal uses should continue to include <bits/invoke.h> and use
std::__invoke<R> so that they don't need to include all of <functional>.

Signed-off-by: Jonathan Wakely <jwakely@redhat.com>
libstdc++-v3/ChangeLog:

	* include/std/functional (invoke_r): Define.
	* include/std/version (__cpp_lib_invoke_r): Define.
	* testsuite/20_util/function_objects/invoke/version.cc: Check
	for __cpp_lib_invoke_r as well as __cpp_lib_invoke.
	* testsuite/20_util/function_objects/invoke/4.cc: New test.

diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 131e6629341cb0c92c74e4c62d710e38cda474b2..0b257926fd550cd869dc7729239a2cbf09157612 100644 (file)
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -96,6 +96,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       return std::__invoke(std::forward<_Callable>(__fn),
                           std::forward<_Args>(__args)...);
     }
+
+#if __cplusplus > 202002L
+# define __cpp_lib_invoke_r 202106L
+
+  /// Invoke a callable object and convert the result to _Res.
+  template<typename _Res, typename _Callable, typename... _Args>
+    requires is_invocable_r_v<_Res, _Callable, _Args...>
+    constexpr _Res
+    invoke_r(_Callable&& __fn, _Args&&... __args)
+    noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
+    {
+      return std::__invoke_r<_Res>(std::forward<_Callable>(__fn),
+                                  std::forward<_Args>(__args)...);
+    }
+#endif // C++23
 #endif // C++17
 
   template<typename _MemFunPtr,

diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 70d573bb5174949e48612119535fdfb96ca6f5b5..f950bf0f0dbf59f14e02f8177c2a61b22bba414f 100644 (file)
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -278,6 +278,7 @@
 
 #if __cplusplus > 202002L
 // c++2b
+#define __cpp_lib_invoke_r 202106L
 #define __cpp_lib_is_scoped_enum 202011L
 #define __cpp_lib_string_contains 202011L
 #define __cpp_lib_to_underlying 202102L

diff --git a/libstdc++-v3/testsuite/20_util/function_objects/invoke/4.cc b/libstdc++-v3/testsuite/20_util/function_objects/invoke/4.cc
new file mode 100644 (file)
index 0000000..3ee6711
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/function_objects/invoke/4.cc
@@ -0,0 +1,59 @@
+// { dg-options "-std=gnu++2b" }
+// { dg-do compile { target c++23 } }
+
+#include <functional>
+
+#ifndef __cpp_lib_invoke_r
+# error Feature-test macro for invoke_r is missing in <functional>
+#elif __cpp_lib_invoke_r < 202106L
+# error Feature-test macro for invoke_r has the wrong value in <functional>
+#endif
+
+constexpr int sq(int i) { return i * i; }
+
+template<typename Val, typename Expected>
+constexpr bool chk(Val&& val, Expected&& exp)
+{
+  return std::is_same_v<Val, Expected> && val == exp;
+}
+
+void
+test01()
+{
+  static_assert( chk( std::invoke(sq, 2), 4 ) );
+  static_assert( chk( std::invoke_r<int>(sq, 3), 9 ) );
+  static_assert( chk( std::invoke_r<char>(sq, 4), '\x10' ) );
+}
+
+struct abstract {
+  virtual ~abstract() = 0;
+  void operator()() noexcept;
+};
+
+static_assert( noexcept(std::invoke(std::declval<abstract>())),
+    "It should be possible to use abstract types with INVOKE" );
+
+static_assert( noexcept(std::invoke_r<void>(std::declval<abstract>())),
+    "It should be possible to use abstract types with INVOKE<R>" );
+
+struct F {
+  void operator()() &;
+  void operator()() && noexcept;
+  int operator()(int);
+  double* operator()(int, int) noexcept;
+};
+struct D { D(void*); };
+
+static_assert( !noexcept(std::invoke(std::declval<F&>())) );
+static_assert( noexcept(std::invoke(std::declval<F>())) );
+static_assert( !noexcept(std::invoke(std::declval<F>(), 1)) );
+static_assert( noexcept(std::invoke(std::declval<F>(), 1, 2)) );
+
+static_assert( !noexcept(std::invoke_r<void>(std::declval<F&>())) );
+static_assert( noexcept(std::invoke_r<void>(std::declval<F>())) );
+static_assert( !noexcept(std::invoke_r<int>(std::declval<F>(), 1)) );
+static_assert( !noexcept(std::invoke_r<void>(std::declval<F>(), 1)) );
+static_assert( !noexcept(std::invoke_r<long>(std::declval<F>(), 1)) );
+static_assert( noexcept(std::invoke_r<void>(std::declval<F>(), 1, 2)) );
+static_assert( noexcept(std::invoke_r<void*>(std::declval<F>(), 1, 2)) );
+static_assert( !noexcept(std::invoke_r<D>(std::declval<F>(), 1, 2)) );

diff --git a/libstdc++-v3/testsuite/20_util/function_objects/invoke/version.cc b/libstdc++-v3/testsuite/20_util/function_objects/invoke/version.cc
index cf1a46a1ada92986b5e7fd42d3b0e24560e5fe40..2dc71aea504f128855a2b70e9d2eb24ac89856cb 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/function_objects/invoke/version.cc
+++ b/libstdc++-v3/testsuite/20_util/function_objects/invoke/version.cc
@@ -7,3 +7,13 @@
 #elif __cpp_lib_invoke < 201411L
 # error Feature-test macro for invoke has the wrong value in <version>
 #endif
+
+#if __cplusplus > 202002L
+#ifndef __cpp_lib_invoke_r
+# error Feature-test macro for invoke_r is missing in <version>
+#elif __cpp_lib_invoke_r < 202106L
+# error Feature-test macro for invoke_r has the wrong value in <version>
+#endif
+#elif defined __cpp_lib_invoke_r
+# error __cpp_lib_invoke_r is defined in <version> before C++23
+#endif