[libc++] [test] Remove IFNDR uses of std::invocable.

[• Quuxplusone]

Summary

libstdc++'s implementation diagnoses these with hard errors: std::invocable<Ts...> is IFNDR whenever std::is_invocable<Ts...> is IFNDR, which happens whenever any of the Ts... are not "complete types, cv void, or arrays of unknown bound." In particular, arrays of known bound of incomplete element types are bad — but references to such arrays are perfectly fine, so that's the fix here.

Fixes https://github.com/llvm/llvm-project/issues/50059

[ldionne]

If this is IFNDR and we are able to diagnose it, why don't we do like libstdc++ and add a test for this implementation-specific diagnostic in test/libcxx?

[• Quuxplusone]

In D116293#3217472, @ldionne wrote:

If this is IFNDR and we are able to diagnose it, why don't we do like libstdc++ and add a test for this implementation-specific diagnostic in test/libcxx?

Because https://quuxplusone.github.io/blog/2021/12/27/libstdcxx-what-are-you-doing/

[ldionne]

In D116293#3217541, @Quuxplusone wrote:

In D116293#3217472, @ldionne wrote:

If this is IFNDR and we are able to diagnose it, why don't we do like libstdc++ and add a test for this implementation-specific diagnostic in test/libcxx?

Because https://quuxplusone.github.io/blog/2021/12/27/libstdcxx-what-are-you-doing/

Makes sense.

libcxx/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp

 static_assert(std::invocable<multiple_overloads, multiple_overloads::A>);
 static_assert(std::invocable<multiple_overloads, multiple_overloads::B>);
 static_assert(std::invocable<multiple_overloads, int>);
 static_assert(!std::invocable<multiple_overloads, multiple_overloads::AB>);
 static_assert(!std::invocable<multiple_overloads, multiple_overloads::O>);
 } // namespace function_objects
 
 namespace pointer_to_member_functions {
-// clang-format off
   template<class Member, class T, class... Args>
   constexpr bool check_member_is_invocable()
   {
-    constexpr bool result = std::invocable<Member, T, Args...>;
+    constexpr bool result = std::invocable<Member, T&&, Args...>;
     using uncv_t = std::remove_cvref_t<T>;
     static_assert(std::invocable<Member, uncv_t*, Args...> == result);
     static_assert(std::invocable<Member, std::unique_ptr<uncv_t>, Args...> == result);
     static_assert(std::invocable<Member, std::reference_wrapper<uncv_t>, Args...> == result);
     static_assert(!std::invocable<Member, std::nullptr_t, Args...>);
     static_assert(!std::invocable<Member, int, Args...>);
     static_assert(!std::invocable<Member, int*, Args...>);
     static_assert(!std::invocable<Member, double*, Args...>);
     struct S2 {};
     static_assert(!std::invocable<Member, S2*, Args...>);
     return result;
   }
-// clang-format on
 
 static_assert(check_member_is_invocable<int S::*, S>());
 static_assert(std::invocable<int S::*, S&>);
 static_assert(std::invocable<int S::*, S const&>);
 static_assert(std::invocable<int S::*, S volatile&>);
 static_assert(std::invocable<int S::*, S const volatile&>);
 static_assert(std::invocable<int S::*, S&&>);
 static_assert(std::invocable<int S::*, S const&&>);

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp

 static_assert(std::regular_invocable<multiple_overloads, multiple_overloads::A>);
 static_assert(std::regular_invocable<multiple_overloads, multiple_overloads::B>);
 static_assert(std::regular_invocable<multiple_overloads, int>);
 static_assert(!std::regular_invocable<multiple_overloads, multiple_overloads::AB>);
 static_assert(!std::regular_invocable<multiple_overloads, multiple_overloads::O>);
 } // namespace function_objects
 
 namespace pointer_to_member_functions {
-// clang-format off
   template<class Member, class T, class... Args>
   constexpr bool check_member_is_invocable()
   {
-    constexpr bool result = std::regular_invocable<Member, T, Args...>;
+    constexpr bool result = std::regular_invocable<Member, T&&, Args...>;
     using uncv_t = std::remove_cvref_t<T>;
     static_assert(std::regular_invocable<Member, uncv_t*, Args...> == result);
     static_assert(std::regular_invocable<Member, std::unique_ptr<uncv_t>, Args...> == result);
     static_assert(std::regular_invocable<Member, std::reference_wrapper<uncv_t>, Args...> == result);
     static_assert(!std::regular_invocable<Member, std::nullptr_t, Args...>);
     static_assert(!std::regular_invocable<Member, int, Args...>);
     static_assert(!std::regular_invocable<Member, int*, Args...>);
     static_assert(!std::regular_invocable<Member, double*, Args...>);
     struct S2 {};
     static_assert(!std::regular_invocable<Member, S2*, Args...>);
     return result;
   }
-// clang-format on
 
 static_assert(check_member_is_invocable<int S::*, S>());
 static_assert(std::regular_invocable<int S::*, S&>);
 static_assert(std::regular_invocable<int S::*, S const&>);
 static_assert(std::regular_invocable<int S::*, S volatile&>);
 static_assert(std::regular_invocable<int S::*, S const volatile&>);
 static_assert(std::regular_invocable<int S::*, S&&>);
 static_assert(std::regular_invocable<int S::*, S const&&>);

libcxx/test/std/ranges/range.access/data.pass.cpp

 
 using RangeDataT = decltype(std::ranges::data);
 
 static int globalBuff[2];
 
 struct Incomplete;
 
 static_assert(!std::is_invocable_v<RangeDataT, Incomplete[]>);
-static_assert(!std::is_invocable_v<RangeDataT, Incomplete[2]>);
-static_assert(!std::is_invocable_v<RangeDataT, Incomplete[2][2]>);
+static_assert(!std::is_invocable_v<RangeDataT, Incomplete(&&)[2]>);
+static_assert(!std::is_invocable_v<RangeDataT, Incomplete(&&)[2][2]>);
 static_assert(!std::is_invocable_v<RangeDataT, int [1]>);
 static_assert(!std::is_invocable_v<RangeDataT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeDataT, int (&)[1]>);
 
 struct DataMember {
   int x;
   constexpr const int *data() const { return &x; }
 };