[libcxx] [test] Use dedicated types for the invocable concept tests for multiple overloads

[mstorsjo]

Summary

This should be clearer, instead of relying on rules for implicit
conversions regarding built in float/integer types.

[curdeius]

I think that now we test less than before. Precisely, this code tested before that e.g. one could invoke f(double) with a float argument.
I'd like to see:

struct DA : A {};
struct DB : B {};

static_assert(std::regular_invocable<multiple_overloads&, multiple_overloads::DA>);
static_assert(std::regular_invocable<multiple_overloads&, multiple_overloads::DB>);

(and the same for std::invocable)

Apart from that, it looks good.

[mstorsjo]

Updated to include tests that a derived type can be converted to a base type.

[curdeius]

LGTM.

[ldionne]

That was the intent of my comment on the other review (and Arthur's original comment too) AFAICT. Thanks!

[• Quuxplusone]

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

240

@curdeius wrote:

I think that now we test less than before. [...] I'd like to see:
struct DA : A {};

I had tested that codepath (that invocable deals correctly with implicit-conversions-to-the-parameter-type) by std::invocable<multiple_overloads, int> (int being implicitly convertible to B).
There's certainly no reason to test all DA and DB and int — all three are exactly isomorphic, user-defined implicit conversions via non-explicit constructor.

@curdeius, any objection if I re-remove DA and DB? (If so: Any objection if I remove DB and B(int)? If so: I'll remove DB.)

[curdeius]

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

240

I agree that we don't need both DA and DB at the same time, the same way we don't need both A and B at the same time.
So, go on.

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

 static_assert(std::invocable<rvalue_cv_function_object volatile, int*>);
 static_assert(std::invocable<rvalue_cv_function_object const volatile, int*>);
 static_assert(!std::invocable<rvalue_cv_function_object&, int*>);
 static_assert(!std::invocable<rvalue_cv_function_object const&, int*>);
 static_assert(!std::invocable<rvalue_cv_function_object volatile&, int*>);
 static_assert(!std::invocable<rvalue_cv_function_object const volatile&, int*>);
 
 struct multiple_overloads {
-  bool operator()();
-  void operator()(int);
-  int operator()(double);
-};
-static_assert(std::invocable<multiple_overloads&>);
-static_assert(std::invocable<multiple_overloads&, short>);
+  struct A {};
+  struct B { B(int); };
+  struct AB : A, B {};
+  struct O {};
+  struct DA : A {};
+  struct DB : B {};
+  void operator()(A) {};
+  void operator()(B) {};
+};
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::A>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::B>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::DA>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::DB>);
 static_assert(std::invocable<multiple_overloads&, int>);
-static_assert(!std::invocable<multiple_overloads&, long long>);
-static_assert(std::invocable<multiple_overloads&, double>);
-static_assert(std::invocable<multiple_overloads&, float>);
-static_assert(std::invocable<multiple_overloads&, short&>);
+static_assert(!std::invocable<multiple_overloads&, multiple_overloads::AB>);
+static_assert(!std::invocable<multiple_overloads&, multiple_overloads::O>);
+
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::A&>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::B&>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::DA&>);
+static_assert(std::invocable<multiple_overloads&, multiple_overloads::DB&>);
 static_assert(std::invocable<multiple_overloads&, int&>);
-static_assert(!std::invocable<multiple_overloads&, long long>);
-static_assert(std::invocable<multiple_overloads&, float&>);
-static_assert(std::invocable<multiple_overloads&, double&>);
+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>
   [[nodiscard]] constexpr bool check_member_is_invocable()
   {
     constexpr bool result = std::invocable<Member, T, Args...>;

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

 static_assert(!std::regular_invocable<rvalue_cv_function_object&, int*>);
 static_assert(!std::regular_invocable<rvalue_cv_function_object const&, int*>);
 static_assert(
     !std::regular_invocable<rvalue_cv_function_object volatile&, int*>);
 static_assert(
     !std::regular_invocable<rvalue_cv_function_object const volatile&, int*>);
 
 struct multiple_overloads {
-  bool operator()();
-  void operator()(int);
-  int operator()(double);
-};
-static_assert(std::regular_invocable<multiple_overloads&>);
-static_assert(std::regular_invocable<multiple_overloads&, short>);
+  struct A {};
+  struct B { B(int); };
+  struct AB : A, B {};
+  struct O {};
+  struct DA : A {};
+  struct DB : B {};
+  void operator()(A) {};
+  void operator()(B) {};
+};
+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&, multiple_overloads::DA>);
+static_assert(std::regular_invocable<multiple_overloads&, multiple_overloads::DB>);
 static_assert(std::regular_invocable<multiple_overloads&, int>);
-static_assert(!std::regular_invocable<multiple_overloads&, long long>);
-static_assert(std::regular_invocable<multiple_overloads&, double>);
-static_assert(std::regular_invocable<multiple_overloads&, float>);
-static_assert(std::regular_invocable<multiple_overloads&, short&>);
+static_assert(!std::regular_invocable<multiple_overloads&, multiple_overloads::AB>);
+static_assert(!std::regular_invocable<multiple_overloads&, multiple_overloads::O>);
+
+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&, multiple_overloads::DA&>);
+static_assert(std::regular_invocable<multiple_overloads&, multiple_overloads::DB&>);
 static_assert(std::regular_invocable<multiple_overloads&, int&>);
-static_assert(!std::regular_invocable<multiple_overloads&, long long&>);
-static_assert(std::regular_invocable<multiple_overloads&, float&>);
-static_assert(std::regular_invocable<multiple_overloads&, double&>);
+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>
   [[nodiscard]] constexpr bool check_member_is_invocable()
   {
     constexpr bool result = std::regular_invocable<Member, T, Args...>;