[libc++] type_traits: use __is_core_convertible in __invokable_r.

[jacobsa]

Summary

This fixes incorrect handling of non-moveable types, adding tests for this case.
See issue 55346.

The current implementation is based on is_convertible, which is
defined in terms of
validity of the following function:

To test() {
  return declval<From>();
}

But this doesn't work if To and From are both some non-moveable type, which the
definition of implicit
conversions says should work due to guaranteed copy elision:

To to = E;  // E has type From

It is this latter definition that is used in the
definition
of INVOKE<R>. Make invokable_r use is_core_convertible, which
captures the ability to use guaranteed copy elision, making the
definition correct for non-moveable types.

Fixes llvm/llvm-project#55346.

[jacobsa]

Remove the "fixes" part of the description.

I forgot that I need another commit for std::is_nothrow_invocable_r
afterward.

[philnik]

You can also put is_nothrow_invocable_r in this PR if you want. The PR is small enough.

libcxx/include/type_traits

3695–3698

Is there a reason you don't fix __invokable_r?

3719–3740

We normally don't put comments to explain the standard. We have standard for documentation.

3741

This seems more in line with how invoke_result is used.

3742

Why are you inheriting from is_convertible and then overwrite all the members?

3746

We usually use class and not typename.

3747

You have to _Uglify all the names. These functions shouldn't be static. They should never be instantiated anyways. Could you rename this to _IsImplicitlyConvertible or something similar? That would remove the need for the comment above since the code is self explanatory.

3749–3751

Couldn't you just use std::declval?

3758

We use these meta programming techniques all over the place. We don't have to document what this does.

3775

libcxx/test/libcxx/type_traits/is_invocable_r.pass.cpp

1 ↗

(On Diff #428330)

This file is missing the license header. It should also be in test/std since it's standard behaviour and nothing libc++ specific.

5–8 ↗

(On Diff #428330)

Same for the other tests

[philnik]

libcxx/test/libcxx/type_traits/is_invocable_r.pass.cpp

2 ↗

(On Diff #428330)

You should also put the synopsis here.

93–97 ↗

(On Diff #428330)

You can make this file a .compile.pass.cpp. Then you don't have to add a main.

[jacobsa]

Address comments from philnik.

[jacobsa]

@philnik: thanks for the quick review! Sorry if I've made any dumb mistakes
here; this is my first time contributing and I'm not familiar with the style,
processes, or tools.

I've left is_nothrow_invocable_r out of this PR to keep it as small as
possible. After learning from this one, the next will require fewer comments.
:-)

By the way, do you know what's up with the failed AIX build? It seems like this
is a pre-existing failure; is it common for that to happen?

libcxx/include/type_traits

3741

Sorry, I'm not sure what you mean here; could you elaborate? "Convert from
_From to _To" seems like a natural order, and matches is_convertible.

3742

Oops, this was an editing mistake. Removed; thanks for catching.

3747

I've uglified the names. Can you tell me why it's necessary to do so? I've
never understood this, since we're already in the scope of an internal struct.

I'm not sure these can/should be non-static, since it messes with the ability
to have a constant expression for the decltype tests below, and requires them
to be a terrible mouthful. See below, which also doesn't work for a reason I
haven't dug into. static seems preferable to this. Do you think this is
important?

template <class _Tp, class = decltype(std::declval<__is_implicitly_convertible>()
                                          .template _RequireImplicitlyConvertibleTo<_To>(_Make<_Tp>()))>
true_type _TestImplicitConversion(int);

[...]

using type = decltype(std::declval<__is_implicitly_convertible>().template _TestImplicitConversion<_From>(0));

3749–3751

That results in an rvalue reference, so it doesn't work correctly for
non-moveable types. The point is to lean on guaranteed copy elision to give the
right answer for those types, matching the standard which defines this in terms
of initialization from an expression of type _From, not _From&&.

libcxx/test/libcxx/type_traits/is_invocable_r.pass.cpp

2 ↗

(On Diff #428330)

Done, although I'm not sure if there is a standard form of synopsis. I've put
something very brief here, because it seems like it's self-explanatory from the
name of the file.

93–97 ↗

(On Diff #428330)

Ah, nice tip. Done.

[philnik]

libcxx/include/type_traits

3741

I think it's debatable whether _From _To is the natural order. I always have to look that up. But I'm Ok with keeping it the same as is_convertible.

3747

I've uglified the names. Can you tell me why it's necessary to do so? I've never understood this, since we're already in the scope of an internal struct.

We have to _Uglify all the names because a User might #define Make "This is definitely not an identifier" and it is perfectly legal. We don't have to do the same shenanigans in files that the user will never see the internals of. You might notice that we don't _Uglify all the names in libcxx/src. There we only _Uglify the public ones.
So at some point in the future, when modules are used everywhere and the standard doesn't define things in terms of headers anymore we can stop _Uglifying the new code. So we can probably stop in 10 years if we're lucky.

I'm not sure these can/should be non-static, since it messes with the ability to have a constant expression for the decltype tests below [...]

Oops, I forgot that they are part of a struct. Ignore that part.

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp

12

75

Could you also add tests with arguments?

80

84

92

Could you also add all the tests for is_invocable_r?

[philnik]

Sorry I missed this: The AIX 32 bit build is currently broken in trunk. You can ignore that failure.

[jacobsa]

Update based on comments from philnik.

[jacobsa]

Dumb question: is there a way to see a list of unresolved comments? All I can
see how to do is look at _all_ the comments in the diff view, which is hard
to parse when there are a lot of resolved ones. I'm not 100% sure I addressed
all of your comments.

libcxx/include/type_traits

3747

Ah right, thanks. I forgot about the preprocessor!

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp

84

It's this way on purpose: this is showing that it's possible to use the
function to initialize a CantMove, i.e. no move constructor is necessary for
such a result type when invoking the function.

92

I assume you don't mean _all_ the tests, right? That seems unnecessary; we're
a lot more likely to have bugs and inconsistencies in the two sets of tests
than for the two implementations to be out of sync. I added a test confirming
that it exists and works. PTAL.

[philnik]

In D125300#3505552, @jacobsa wrote:

Dumb question: is there a way to see a list of unresolved comments? All I can
see how to do is look at _all_ the comments in the diff view, which is hard
to parse when there are a lot of resolved ones. I'm not 100% sure I addressed
all of your comments.

I don't know what you are looking at exactly, but on the top right you should see something like 12 / 23 Comments. You can click on that to go to the next unresolved comment. Right next to that you can also select Hide "done" Inlines.

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp

84

Right. My brain probably went "Oh look, a value initialization with the type spelled out twice; let's just spell it once".

92

No, I meant all the tests. The tests should be able to test all standard library implementations and not just libc++. This means that we shouldn't just test code paths we know exist, but also ones which could very well exist. is_invocable_r and is_invocable_r_v could be implemented completely differently, so we should test for everything. This also future-proofs the tests. We almost never change any of the tests once they are written because the API is set in stone from now 'till the end of time (or until at some point the standard breaks the API, which hasn't happened in the last 25 years). If anything we almost always only add new tests.

[jacobsa]

In D125300#3505634, @philnik wrote:

In D125300#3505552, @jacobsa wrote:

Dumb question: is there a way to see a list of unresolved comments? All I can
see how to do is look at _all_ the comments in the diff view, which is hard
to parse when there are a lot of resolved ones. I'm not 100% sure I addressed
all of your comments.

I don't know what you are looking at exactly, but on the top right you should see something like 12 / 23 Comments. You can click on that to go to the next unresolved comment. Right next to that you can also select Hide "done" Inlines.

I see that this is supposed to work; there is even a screenshot here:

https://secure.phabricator.com/rPb3b30dde6ac99786a77f903823ebf259db6e3adc

But my diff view doesn't look like that; it doesn't have any of the widgets
shown in that screenshot. Here's what I see: https://imgur.com/FdJwQz1

libcxx/include/type_traits

3695–3698

Sorry, I don't know how I missed this. Done, and i see that this now fixes
is_nothrow_invokable_r too, so I've added a test for that. In that case I
haven't duplicated the test for _v, since the existing test file doesn't do
that with all the other cases.

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp

92

Ack, done.

[jacobsa]

Update based on feedback from philnik. Fix __invokable_r instead.

[jacobsa]

FYI, I messed up and submitted the above reply early, sorry. Please take
another look if you're reading by email; I've edited the comment.

[jacobsa]

Put "fixes" back into the commit message now that this also handles
is_nothrow_invocable_r.

[philnik]

In D125300#3507841, @jacobsa wrote:

In D125300#3505634, @philnik wrote:

In D125300#3505552, @jacobsa wrote:

Dumb question: is there a way to see a list of unresolved comments? All I can
see how to do is look at _all_ the comments in the diff view, which is hard
to parse when there are a lot of resolved ones. I'm not 100% sure I addressed
all of your comments.

I don't know what you are looking at exactly, but on the top right you should see something like 12 / 23 Comments. You can click on that to go to the next unresolved comment. Right next to that you can also select Hide "done" Inlines.

I see that this is supposed to work; there is even a screenshot here:

https://secure.phabricator.com/rPb3b30dde6ac99786a77f903823ebf259db6e3adc

But my diff view doesn't look like that; it doesn't have any of the widgets
shown in that screenshot. Here's what I see: https://imgur.com/FdJwQz1

You have to scroll down a bit further. Then a banner should pop up at the top of the screen where the other options are. BTW if you want some of your questions get answered a bit quicker you might want to join the LLVM discord.

LGTM % nits. If you don't have commit access (which I assume) please provide "Your Name" <[e-mail]> for attribution.

libcxx/include/type_traits

3508–3509

Could you add a comment why you can't just use std::declval? I think that's not obvious.

libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp

200–201

Could you also add static_asserts for the _v version?

[jacobsa]

Address latest comments.

[jacobsa]

Thanks! You can credit Aaron Jacobs <[e-mail]>.

[jacobsa]

@philnik sorry if this is an obvious question, but what's the next step here?
Are you able to approve the change so I can commit it, or do you commit
giving me attribution, or what?

[philnik]

In D125300#3513912, @jacobsa wrote:

@philnik sorry if this is an obvious question, but what's the next step here?
Are you able to approve the change so I can commit it, or do you commit
giving me attribution, or what?

A second person from the #libc group has to approve and then I (or someone else) can commit it. The review pipeline is currently stalled a bit so it might take another week, probably mostly depending on when @ldionne has some time. Feel free to ping in a week or so if nothing happened until then.

[jloser]

libcxx/include/type_traits

3496

// Detects whether an expression of type _From can be implicitly converted to _To

3499

// function and therefore gives the wrong answer for non-movable types.

[jacobsa]

Fix typos pointed out by jloser.

[EricWF]

I think we already have a trait for this. It's __is_core_convertible. Could you use that instead?

libcxx/include/type_traits

3503

Use __is_core_convertible, which already addresses this.

[EricWF]

Requesting the __core_is_convertible changes formally to put this review in the correct bucket.

libcxx/include/type_traits

3547

Not sure this comment adds anything.

[jacobsa]

Use __is_core_convertible rather than reimplementing it.

[jacobsa]

Thanks Eric, PTAL.

libcxx/include/type_traits

3503

I didn't know this existed. That's much better, thanks.

[philnik]

libcxx/include/type_traits

3543

Well, that's a lot shorter. Although I have to say __is_core_convertible isn't a very intuitive name. Is there any reason it is called that @EricWF?

[philnik]

@jacobsa could you add [libc++] to the name of the PR?

[jacobsa]

Add [libc++] to the title.

[EricWF]

Thanks for the fix!

libcxx/include/type_traits

3543

I think it refers to the "core language" definition of convertibility rather than the library definition?

[jacobsa]

@EricWF @philnik Thanks! But how do I actually commit this? Do you need to do it for me?

libcxx/include/type_traits

 template <class _Fp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr auto
 __invoke(_Fp&& __f, _Args&& ...__args)
     noexcept(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
     -> decltype(      static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...))
     { return          static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
 
-// __invokable
-template <class _Ret, class _Fp, class ..._Args>
-struct __invokable_r
-{
+// __invokable_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 _Ret, class _Fp, class... _Args>
+struct __invokable_r {
   template <class _XFp, class ..._XArgs>
   static auto __try_call(int) -> decltype(
     _VSTD::__invoke(declval<_XFp>(), declval<_XArgs>()...));
   template <class _XFp, class ..._XArgs>
   static __nat __try_call(...);
 
   // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
   // or incomplete array types as required by the standard.
   using _Result = decltype(__try_call<_Fp, _Args...>(0));
 
   using type =
   typename conditional<
       _IsNotSame<_Result, __nat>::value,
       typename conditional<
           is_void<_Ret>::value,
           true_type,
-          is_convertible<_Result, _Ret>
+          __is_implicitly_convertible<_Result, _Ret>
       >::type,
       false_type
   >::type;
   static const bool value = type::value;
 };
+
+// __invokable
 template <class _Fp, class ..._Args>
 using __invokable = __invokable_r<void, _Fp, _Args...>;
 
 template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args>
 struct __nothrow_invokable_r_imp {
   static const bool value = false;
 };
 

 {
 };
 
 template <class _Fn, class... _Args>
 using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
 
 // 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>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
     : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
 
 template <class _Ret, class _Fn, class ..._Args>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r
     : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
 
 template <class _Fn, class ..._Args>
 inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
 
 template <class _Ret, class _Fn, class ..._Args>
 inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
 
 #endif // _LIBCPP_STD_VER > 14
 
 // __swappable
 
 template <class _Tp> struct __is_swappable;
 template <class _Tp> struct __is_nothrow_swappable;
 
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
 using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
 #else
 template <class>
 using __swap_result_t = void;
 #endif
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR_AFTER_CXX17 __swap_result_t<_Tp>
 swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
                                     is_nothrow_move_assignable<_Tp>::value);
 
 template<class _Tp, size_t _Np>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if<
     __is_swappable<_Tp>::value
 >::type
 swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
 
 namespace __detail
 {
 // ALL generic swap overloads MUST already have a declaration available at this point.
 
 template <class _Tp, class _Up = _Tp,
           bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// is_invocable_r
+
+#include <type_traits>
+
+// Non-invocable types
+
+static_assert(!std::is_invocable_r<void, void>::value);
+static_assert(!std::is_invocable_r<void, int>::value);
+static_assert(!std::is_invocable_r<void, int*>::value);
+static_assert(!std::is_invocable_r<void, int&>::value);
+static_assert(!std::is_invocable_r<void, int&&>::value);
+
+// Result type matches
+
+template <typename T>
+T Return();
+
+static_assert(std::is_invocable_r<int, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<char, decltype(Return<char>)>::value);
+static_assert(std::is_invocable_r<int*, decltype(Return<int*>)>::value);
+static_assert(std::is_invocable_r<int&, decltype(Return<int&>)>::value);
+static_assert(std::is_invocable_r<int&&, decltype(Return<int&&>)>::value);
+
+// void result type
+
+// Any actual return type should be useable with a result type of void.
+static_assert(std::is_invocable_r<void, decltype(Return<void>)>::value);
+static_assert(std::is_invocable_r<void, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<void, decltype(Return<int*>)>::value);
+static_assert(std::is_invocable_r<void, decltype(Return<int&>)>::value);
+static_assert(std::is_invocable_r<void, decltype(Return<int&&>)>::value);
+
+// const- and volatile-qualified void should work too.
+static_assert(std::is_invocable_r<const void, decltype(Return<void>)>::value);
+static_assert(std::is_invocable_r<const void, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<volatile void, decltype(Return<void>)>::value);
+static_assert(std::is_invocable_r<volatile void, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<const volatile void, decltype(Return<void>)>::value);
+static_assert(std::is_invocable_r<const volatile void, decltype(Return<int>)>::value);
+
+// 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<char, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<const int*, decltype(Return<int*>)>::value);
+static_assert(std::is_invocable_r<void*, decltype(Return<int*>)>::value);
+static_assert(std::is_invocable_r<const int&, decltype(Return<int>)>::value);
+static_assert(std::is_invocable_r<const int&, decltype(Return<int&>)>::value);
+static_assert(std::is_invocable_r<const int&, decltype(Return<int&&>)>::value);
+static_assert(std::is_invocable_r<const char&, decltype(Return<int>)>::value);
+
+// But not a result type where the conversion doesn't work.
+static_assert(!std::is_invocable_r<int, decltype(Return<void>)>::value);
+static_assert(!std::is_invocable_r<int, decltype(Return<int*>)>::value);
+
+// 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 functions that return that type.
+CantMove MakeCantMove() { return {}; }
+CantMove MakeCantMoveWithArg(int) { return {}; }
+
+// Assumption check: it should be possible to call one of those functions and
+// use it to initialize a CantMove object.
+CantMove cant_move = MakeCantMove();
+
+// Therefore std::is_invocable_r should agree that they can be invoked to yield
+// a CantMove.
+static_assert(std::is_invocable_r<CantMove, decltype(MakeCantMove)>::value);
+static_assert(std::is_invocable_r<CantMove, decltype(MakeCantMoveWithArg), int>::value);
+
+// Of course it still shouldn't be possible to call one of the functions and get
+// back some other type.
+static_assert(!std::is_invocable_r<int, decltype(MakeCantMove)>::value);
+
+// And the argument types should still be important.
+static_assert(!std::is_invocable_r<CantMove, decltype(MakeCantMove), int>::value);
+static_assert(!std::is_invocable_r<CantMove, decltype(MakeCantMoveWithArg)>::value);
+
+// is_invocable_r
+
+// The struct form should be available too, not just the _v variant.
+static_assert(std::is_invocable_r<int, decltype(Return<int>)>::value);
+static_assert(!std::is_invocable_r<int*, decltype(Return<int>)>::value);

libcxx/test/std/utilities/meta/meta.rel/is_invocable_r_v.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// 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 functions that return that type.
+CantMove MakeCantMove() { return {}; }
+CantMove MakeCantMoveWithArg(int) { return {}; }
+
+// Assumption check: it should be possible to call one of those functions and
+// use it to initialize a CantMove object.
+CantMove cant_move = MakeCantMove();
+
+// Therefore std::is_invocable_r should agree that they can be invoked to yield
+// a CantMove.
+static_assert(std::is_invocable_r_v<CantMove, decltype(MakeCantMove)>);
+static_assert(std::is_invocable_r_v<CantMove, decltype(MakeCantMoveWithArg), int>);
+
+// Of course it still shouldn't be possible to call one of the functions and get
+// back some other type.
+static_assert(!std::is_invocable_r_v<int, decltype(MakeCantMove)>);
+
+// And the argument types should still be important.
+static_assert(!std::is_invocable_r_v<CantMove, decltype(MakeCantMove), int>);
+static_assert(!std::is_invocable_r_v<CantMove, decltype(MakeCantMoveWithArg)>);
+
+// is_invocable_r
+
+// The struct form should be available too, not just the _v variant.
+static_assert(std::is_invocable_r<int, decltype(Return<int>)>::value);
+static_assert(!std::is_invocable_r<int*, decltype(Return<int>)>::value);

libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp

int main(int, char**) {
   {
     // Check that PMD derefs are noexcept
     using Fn = int(Tag::*);
     static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
     static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
     static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
   }
   {
+    // Check that it's fine if the result type is non-moveable.
+    struct CantMove {
+      CantMove() = default;
+      CantMove(CantMove&&) = delete;
+    };
+
+    static_assert(!std::is_move_constructible_v<CantMove>);
+    static_assert(!std::is_copy_constructible_v<CantMove>);
+
+    using Fn = CantMove() noexcept;
+
+    static_assert(std::is_nothrow_invocable_r<CantMove, Fn>::value);
+    static_assert(!std::is_nothrow_invocable_r<CantMove, Fn, int>::value);
+  }
+  {
     // Check for is_nothrow_invocable_v
     using Fn = CallObject<true, int>;
     static_assert(std::is_nothrow_invocable_v<Fn>, "");
     static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
   }
   {
     // Check for is_nothrow_invocable_r_v
     using Fn = CallObject<true, int>;
     static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
     static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
   }
   test_noexcept_function_pointers();
 
   return 0;
 }