<functional>: Implement invoke_r

stl/inc/functional

@@ -29,6 +29,19 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
+#if _HAS_CXX23
+template <class _Result_type, class _Callable, class... _Types,
+    enable_if_t<is_invocable_r_v<_Result_type, _Callable, _Types...>, int> = 0>
+_NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args) noexcept(
+    is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
+    if constexpr (is_void_v<_Result_type>) {
+        (void) _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    } else {
+        return _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    }
+}
+#endif // _HAS_CXX23
+
 // plus, minus, and multiplies are defined in <xstddef>
 
 template <class _Ty = void>

stl/inc/yvals_core.h

@@ -267,6 +267,7 @@
 // P1682R3 to_underlying() For Enumerations
 // P1951R1 Default Template Arguments For pair's Forwarding Constructor
 // P1989R2 Range Constructor For string_view
+// P2136R3 invoke_r()
 // P2166R1 Prohibiting basic_string And basic_string_view Construction From nullptr
 // P2186R2 Removing Garbage Collection Support
 
@@ -1354,6 +1355,7 @@
 #define __cpp_lib_allocate_at_least 202106L
 #endif // __cpp_lib_concepts
 
+#define __cpp_lib_invoke_r       202106L
 #define __cpp_lib_is_scoped_enum 202011L
 
 #ifdef __cpp_lib_concepts

tests/std/test.lst

@@ -428,6 +428,7 @@ tests\P1614R2_spaceship
 tests\P1645R1_constexpr_numeric
 tests\P1682R3_to_underlying
 tests\P1951R1_default_arguments_pair_forward_ctor
+tests\P2136R3_invoke_r
 tests\P2162R2_std_visit_for_derived_classes_from_variant
 tests\VSO_0000000_allocator_propagation
 tests\VSO_0000000_any_calling_conventions

tests/std/tests/P2136R3_invoke_r/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst

tests/std/tests/P2136R3_invoke_r/test.cpp

@@ -0,0 +1,115 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <functional>
+#include <string>
+#include <type_traits>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+using namespace std;
+
+// TRANSITION, DevCom-1457457
+namespace detail {
+    static constexpr bool permissive() {
+        return false;
+    }
+
+    template <class>
+    struct DependentBase {
+        static constexpr bool permissive() {
+            return true;
+        }
+    };
+
+    template <class T>
+    struct Derived : DependentBase<T> {
+        static constexpr bool test() {
+            return permissive();
+        }
+    };
+} // namespace detail
+constexpr bool is_permissive = detail::Derived<int>::test();
+
+constexpr int square(int n) {
+    return n * n;
+}
+constexpr int square_noexcept(int n) noexcept {
+    return n * n;
+}
+constexpr const char* cstring() noexcept;
+
+struct Thing {
+    int n = 0;
+    constexpr int& moo() {
+        return n;
+    }
+};
+
+struct RefQualified {
+    constexpr int operator()(int&&) && {
+        return 1;
+    }
+    constexpr int operator()(const int&) && {
+        return 2;
+    }
+    constexpr int operator()(int&&) & {
+        return 3;
+    }
+    constexpr int operator()(const int&) & {
+        return 4;
+    }
+};
+
+constexpr bool test_invoke_r() {
+    auto v1 = invoke_r<long>(square, 3);
+    assert(v1 == 9L);
+    STATIC_ASSERT(is_same_v<decltype(v1), long>);
+
+    auto v2 = invoke_r<double>([]() -> int { return 5; });
+    assert(v2 == 5);
+    STATIC_ASSERT(is_same_v<decltype(v2), double>);
+    STATIC_ASSERT(is_void_v<decltype(invoke_r<void>(square, 1))>);
+
+    // TRANSITION, DevCom-1457457
+    STATIC_ASSERT(noexcept(invoke_r<int>(square, 3)) == is_permissive);
+    STATIC_ASSERT(noexcept(invoke(square, 3)) == is_permissive);
+
+    constexpr bool has_noexcept_in_type =
+#ifdef __cpp_noexcept_function_type
+        true;
+#else
+        false;
+#endif
+    STATIC_ASSERT(noexcept(invoke(square_noexcept, 3)) == has_noexcept_in_type);
+    STATIC_ASSERT(noexcept(invoke_r<int>(square_noexcept, 3)) == has_noexcept_in_type);
+    STATIC_ASSERT(noexcept(invoke(cstring)) == has_noexcept_in_type);
+    STATIC_ASSERT(!noexcept(invoke_r<string>(cstring)));
+
+    Thing thing;
+    invoke_r<void>(&Thing::n, thing); // no nodiscard warning
+    STATIC_ASSERT(is_same_v<decltype(invoke(&Thing::moo, thing)), int&>);
+    STATIC_ASSERT(is_same_v<decltype(invoke_r<int>(&Thing::moo, thing)), int>);
+
+    auto lambda = [counter = 0]() mutable { return ++counter; };
+    assert(lambda() == 1);
+    assert(lambda() == 2);
+    assert(invoke_r<int>(lambda) == 3);
+    assert(invoke_r<int>(lambda) == 4);
+    assert(lambda() == 5);
+
+    int lvalue = 0;
+    assert(invoke_r<int>(RefQualified{}, 0) == 1);
+    assert(invoke_r<int>(RefQualified{}, lvalue) == 2);
+    RefQualified r;
+    assert(invoke_r<int>(r, 0) == 3);
+    assert(invoke_r<int>(r, lvalue) == 4);
+
+    return true;
+}
+
+int main() {
+    test_invoke_r();
+    STATIC_ASSERT(test_invoke_r());
+}

tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp

@@ -861,6 +861,16 @@ STATIC_ASSERT(__cpp_lib_interpolate == 201902L);
 STATIC_ASSERT(__cpp_lib_invoke == 201411L);
 #endif
 
+#if _HAS_CXX23
+#ifndef __cpp_lib_invoke_r
+#error __cpp_lib_invoke_r is not defined
+#elif __cpp_lib_invoke_r != 202106L
+#error __cpp_lib_invoke_r is not 202106L
+#else
+STATIC_ASSERT(__cpp_lib_invoke_r == 202106L);
+#endif
+#endif
+
 #if _HAS_CXX17
 #ifndef __cpp_lib_is_aggregate
 #error __cpp_lib_is_aggregate is not defined