Extend is() to correctly handle custom is operator

In current implementation custom is operator (`is_op()` member function)
suffers from implicit casting of its argument. The same issue that were
with function predicates.

After this change we added the check if the cast is lossless or
if the custom is operator is generic function.

Added tests to verify is with various values.

Added new concepts to make checks more readable:
- valid_custom_is_operator
- defined - to check if type is defined (used to determined generic fun)
- predicate_member_fun - to check if member function is a predicate,

Added new type trait:
- argument_of_op_is_t to determined the type of op_is argument,

Correct helper methods:
- argument_of_helper - to handle ref-qualified member functions,
- argument_of_helper - to work with non-copyable types,

Author: filipsajdak

include/cpp2util.h

@@ -369,15 +369,33 @@ auto argument_of_helper(Ret(*) (Arg)) -> Arg;
 template<typename Ret, typename F, typename Arg>
 auto argument_of_helper(Ret(F::*) (Arg)) -> Arg;
 
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg)&) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg)&&) -> Arg;
+
 template<typename Ret, typename F, typename Arg>
 auto argument_of_helper(Ret(F::*) (Arg) const) -> Arg;
 
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg) const&) -> Arg;
+
+template<typename Ret, typename F, typename Arg>
+auto argument_of_helper(Ret(F::*) (Arg) const&&) -> Arg;
+
 template <typename F>
-auto argument_of_helper(F) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));
+auto argument_of_helper(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::operator()));
 
 template <typename T>
 using argument_of_t = CPP2_TYPEOF(argument_of_helper(std::declval<T>()));
 
+template <typename F>
+auto argument_of_helper_op_is(F const&) -> CPP2_TYPEOF(argument_of_helper(&F::op_is));
+
+template <typename T>
+using argument_of_op_is_t = CPP2_TYPEOF(argument_of_helper_op_is(std::declval<T>()));
+
 template <typename T>
 using pointee_t = std::iter_value_t<T>;
 
@@ -428,6 +446,9 @@ concept brace_initializable_to = requires (From x) { To{x}; };
 template< typename X, typename C >
 concept same_type_as = std::same_as<std::remove_cvref_t<X>, std::remove_cvref_t<C>>;
 
+template <typename X>
+concept defined = requires { std::declval<X>(); };
+
 template <typename X>
 concept has_defined_argument = requires {
 	std::declval<argument_of_t<X>>();
@@ -443,6 +464,18 @@ template <typename F, typename X>
 concept valid_predicate = (std::predicate<F, X> && !has_defined_argument<F>)
                           || (std::predicate<F, X> && has_defined_argument<F> && covertible_to_argument_of<X, F>);
 
+template <typename X, typename O, auto mem_fun_ptr>
+concept predicate_member_fun = requires (X x, O o) {
+    { (o.*mem_fun_ptr)(x) } -> std::convertible_to<bool>;
+};
+
+template <typename F, typename X>
+concept valid_custom_is_operator = predicate_member_fun<X, F, &F::op_is>
+                      && ( 
+                        !defined<argument_of_op_is_t<F>>
+                        || brace_initializable_to<X, argument_of_op_is_t<F>> 
+                      );
+
 //-----------------------------------------------------------------------
 //
 //  General helpers
@@ -1299,7 +1332,7 @@ auto is( X const& x ) -> bool {
 inline constexpr auto is( auto const& x, auto&& value ) -> bool
 {
     //  Value with customized operator_is case
-    if constexpr (requires{ x.op_is(value); }) {
+    if constexpr (valid_custom_is_operator<decltype(x), decltype(value)>) {
         return x.op_is(value);
     }
 

regression-tests/pure2-is-with-variable-and-value.cpp2

@@ -0,0 +1,41 @@
+fun: (name, v) = {
+    std::cout << name << ": " << 
+                inspect v -> std::string {
+                is (42) = "42";
+                is (123) = "op_is";
+                is (-123) = "generic op_is";
+                is (4321) = "comperable";
+                is ("text") = "text";
+                is _ = "unknown";
+              }
+              << std::endl;
+}
+
+main: () -> int = {
+    fun("3.14", 3.14);
+    fun("42", 42);
+    fun("WithOp()", WithOp());
+    fun("WithGenOp()", WithGenOp());
+    fun("Cmp()", Cmp());
+    fun("std::string(\"text\")", std::string("text"));
+    fun("\"text\"", "text");
+    fun("std::string_view(\"text\")", std::string_view("text"));
+    fun(":std::vector = ('t','e','x','t','\\0')", :std::vector = ('t','e','x','t','\0'));
+}
+
+WithOp : type = {
+    op_is: (this, x : int) x == 123;
+}
+
+WithGenOp : type = {
+    op_is: (this, x) -> bool = {
+        if constexpr std::convertible_to<decltype(x), int> {
+            return x == -123;
+        }
+        return false;
+    }
+}
+
+Cmp : type = {
+    operator==: (this, x : int) -> bool = x == 4321;
+}

regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.execution

@@ -0,0 +1,9 @@
+3.14: unknown
+42: 42
+WithOp(): unknown
+WithGenOp(): unknown
+Cmp(): comperable
+std::string("text"): text
+"text": text
+std::string_view("text"): text
+:std::vector = ('t','e','x','t','\0'): unknown

regression-tests/test-results/apple-clang-14/pure2-is-with-variable-and-value.cpp.output

@@ -0,0 +1,104 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+
+#line 26 "pure2-is-with-variable-and-value.cpp2"
+class WithOp;
+    
+
+#line 30 "pure2-is-with-variable-and-value.cpp2"
+class WithGenOp;
+    
+
+#line 39 "pure2-is-with-variable-and-value.cpp2"
+class Cmp;
+    
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+auto fun(auto const& name, auto const& v) -> void;
+
+#line 14 "pure2-is-with-variable-and-value.cpp2"
+[[nodiscard]] auto main() -> int;
+
+#line 26 "pure2-is-with-variable-and-value.cpp2"
+class WithOp {
+    public: [[nodiscard]] auto op_is(cpp2::impl::in<int> x) const& -> auto;
+    public: WithOp() = default;
+    public: WithOp(WithOp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(WithOp const&) -> void = delete;
+
+#line 28 "pure2-is-with-variable-and-value.cpp2"
+};
+
+class WithGenOp {
+    public: [[nodiscard]] auto op_is(auto const& x) const& -> bool;
+    public: WithGenOp() = default;
+    public: WithGenOp(WithGenOp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(WithGenOp const&) -> void = delete;
+
+
+#line 37 "pure2-is-with-variable-and-value.cpp2"
+};
+
+class Cmp {
+    public: [[nodiscard]] auto operator==(cpp2::impl::in<int> x) const& -> bool;
+    public: Cmp() = default;
+    public: Cmp(Cmp const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(Cmp const&) -> void = delete;
+
+#line 41 "pure2-is-with-variable-and-value.cpp2"
+};
+
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-is-with-variable-and-value.cpp2"
+auto fun(auto const& name, auto const& v) -> void{
+#line 2 "pure2-is-with-variable-and-value.cpp2"
+    std::cout << name << ": " << 
+                [&] () -> std::string { auto&& _expr = v;
+                if (cpp2::impl::is(_expr, (42))) { if constexpr( requires{"42";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("42")),std::string> ) return "42"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, 123)) { if constexpr( requires{"op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("op_is")),std::string> ) return "op_is"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, -123)) { if constexpr( requires{"generic op_is";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("generic op_is")),std::string> ) return "generic op_is"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, 4321)) { if constexpr( requires{"comperable";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("comperable")),std::string> ) return "comperable"; else return std::string{}; else return std::string{}; }
+                else if (cpp2::impl::is(_expr, "text")) { if constexpr( requires{"text";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("text")),std::string> ) return "text"; else return std::string{}; else return std::string{}; }
+                else return "unknown"; }
+              () 
+              << std::endl;
+}
+
+#line 14 "pure2-is-with-variable-and-value.cpp2"
+[[nodiscard]] auto main() -> int{
+    fun("3.14", 3.14);
+    fun("42", 42);
+    fun("WithOp()", WithOp());
+    fun("WithGenOp()", WithGenOp());
+    fun("Cmp()", Cmp());
+    fun("std::string(\"text\")", std::string("text"));
+    fun("\"text\"", "text");
+    fun("std::string_view(\"text\")", std::string_view("text"));
+    fun(":std::vector = ('t','e','x','t','\\0')", std::vector{'t', 'e', 'x', 't', '\0'});
+}
+
+#line 27 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto WithOp::op_is(cpp2::impl::in<int> x) const& -> auto { return x == 123;  }
+
+#line 31 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto WithGenOp::op_is(auto const& x) const& -> bool{
+        if constexpr (std::convertible_to<decltype(x),int>) {
+            return x == -123; 
+        }
+        return false; 
+    }
+
+#line 40 "pure2-is-with-variable-and-value.cpp2"
+    [[nodiscard]] auto Cmp::operator==(cpp2::impl::in<int> x) const& -> bool { return x == 4321;  }
+

regression-tests/test-results/pure2-is-with-variable-and-value.cpp

@@ -0,0 +1,2 @@
+pure2-is-with-variable-and-value.cpp2... ok (all Cpp2, passes safety checks)
+