diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -3686,22 +3686,61 @@
 template <class _Fn, class... _Args>
 using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
 
+// is_invocable_r
+
+// Detects whether an express of type _From can be implicitly converted to _To
+// according to [conv]. Note that this is distinct from is_convertible, which
+// for non-reference _From types relies on returning an rvalue reference from a
+// function and therefore gives the wrong answer for non-moveable types.
+//
+// REQUIRES: _From is not cv void.
+template <class _From, class _To>
+struct __is_implicitly_convertible {
+private:
+  template <class _Tp>
+  static void _RequireImplicitlyConvertibleTo(_Tp);
+
+  template <class _Tp>
+  static _Tp _Make();
+
+  template <class _Tp, class = decltype(_RequireImplicitlyConvertibleTo<_To>(_Make<_Tp>()))>
+  static true_type _TestImplicitConversion(int);
+
+  template <class _Tp>
+  static false_type _TestImplicitConversion(...);
+
+public:
+  using type = decltype(_TestImplicitConversion<_From>(0));
+  static constexpr bool value = type::value;
+};
+
+template <class _Void, class _Ret, class _Fn, class... _Args>
+struct __is_invocable_r_impl : public false_type {};
+
+template <class _Ret, class _Fn, class... _Args>
+struct __is_invocable_r_impl<void_t<invoke_result_t<_Fn, _Args...>>, _Ret, _Fn, _Args...>
+    // By now we know that _Fn is invocable with _Args. If _Ret is cv void, the
+    // answer is always yes. Otherwise the actual result type must be implicitly
+    // convertible to _Ret.
+    : conditional_t< is_same_v<remove_cv_t<_Ret>, void>,
+                     true_type, //
+                     __is_implicitly_convertible<invoke_result_t<_Fn, _Args...>, _Ret>> {};
+
+template <class _Ret, class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable_r : __is_invocable_r_impl<void, _Ret, _Fn, _Args...> {};
+
+template <class _Ret, class _Fn, class... _Args>
+inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
+
 // is_invocable
 
 template <class _Fn, class ..._Args>
 struct _LIBCPP_TEMPLATE_VIS is_invocable
     : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
 
-template <class _Ret, class _Fn, class ..._Args>
-struct _LIBCPP_TEMPLATE_VIS is_invocable_r
-    : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
-
 template <class _Fn, class ..._Args>
 inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
 
-template <class _Ret, class _Fn, class ..._Args>
-inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
-
 // is_nothrow_invocable
 
 template <class _Fn, class ..._Args>
diff --git a/libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp b/libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// Tests for is_invocable_r.
+
+#include <type_traits>
+
+// Non-invocable types
+
+static_assert(!std::is_invocable_r_v<void, void>);
+static_assert(!std::is_invocable_r_v<void, int>);
+static_assert(!std::is_invocable_r_v<void, int*>);
+static_assert(!std::is_invocable_r_v<void, int&>);
+static_assert(!std::is_invocable_r_v<void, int&&>);
+
+// Result type matches
+
+template <typename T>
+T Return();
+
+static_assert(std::is_invocable_r_v<int, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<char, decltype(Return<char>)>);
+static_assert(std::is_invocable_r_v<int*, decltype(Return<int*>)>);
+static_assert(std::is_invocable_r_v<int&, decltype(Return<int&>)>);
+static_assert(std::is_invocable_r_v<int&&, decltype(Return<int&&>)>);
+
+// void result type
+
+// Any actual return type should be useable with a result type of void.
+static_assert(std::is_invocable_r_v<void, decltype(Return<void>)>);
+static_assert(std::is_invocable_r_v<void, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<void, decltype(Return<int*>)>);
+static_assert(std::is_invocable_r_v<void, decltype(Return<int&>)>);
+static_assert(std::is_invocable_r_v<void, decltype(Return<int&&>)>);
+
+// const- and volatile-qualified void should work too.
+static_assert(std::is_invocable_r_v<const void, decltype(Return<void>)>);
+static_assert(std::is_invocable_r_v<const void, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<volatile void, decltype(Return<void>)>);
+static_assert(std::is_invocable_r_v<volatile void, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<const volatile void, decltype(Return<void>)>);
+static_assert(std::is_invocable_r_v<const volatile void, decltype(Return<int>)>);
+
+// Conversion of result type
+
+// It should be possible to use a result type to which the actual return type
+// can be converted.
+static_assert(std::is_invocable_r_v<char, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<const int*, decltype(Return<int*>)>);
+static_assert(std::is_invocable_r_v<void*, decltype(Return<int*>)>);
+static_assert(std::is_invocable_r_v<const int&, decltype(Return<int>)>);
+static_assert(std::is_invocable_r_v<const int&, decltype(Return<int&>)>);
+static_assert(std::is_invocable_r_v<const int&, decltype(Return<int&&>)>);
+static_assert(std::is_invocable_r_v<const char&, decltype(Return<int>)>);
+
+// But not a result type where the conversion doesn't work.
+static_assert(!std::is_invocable_r_v<int, decltype(Return<void>)>);
+static_assert(!std::is_invocable_r_v<int, decltype(Return<int*>)>);
+
+// Non-moveable result type
+
+// Define a type that can't be move-constructed.
+struct CantMove {
+  CantMove() = default;
+  CantMove(CantMove&&) = delete;
+};
+
+static_assert(!std::is_move_constructible_v<CantMove>);
+static_assert(!std::is_copy_constructible_v<CantMove>);
+
+// Define a function that returns that type.
+CantMove MakeCantMove() { return CantMove(); }
+
+// Assumption check: it should be possible to call that function and use it to
+// initialize a CantMove object.
+CantMove cant_move = MakeCantMove();
+
+// Therefore std::is_invocable_r should agree that it can be invoked to yield a
+// CantMove.
+static_assert(std::is_invocable_r_v<CantMove, decltype(MakeCantMove)>);
+
+// Of course it still shouldn't be possible to call the function and get back
+// some other type.
+static_assert(!std::is_invocable_r_v<int, decltype(MakeCantMove)>);