Add predicate support for is outside inspect, see #90

Author: hsutter

regression-tests/mixed-inspect-values-2.cpp2

@@ -0,0 +1,45 @@
+
+#include <iostream>
+#include <vector>
+
+constexpr auto less_then = [](int value) {
+    return [=](auto x) { return x < value;};
+};
+
+constexpr auto in = [](auto min, auto max) {
+    return [=](auto x) {
+        return min <= x && x <= max;
+    };
+};
+
+constexpr auto empty = [](auto&& x){
+    return std::empty(x);
+};
+
+main: () -> int = {
+    i := 15;
+
+    std::cout << inspect i -> std::string {
+        is (less_then(10)) = "i less than 10";
+        is (in(11,20)) = "i is between 11 and 20";
+        is _ = "i is out of our interest";
+    } << std::endl;
+
+    if i is less_then(20) {
+        std::cout << "less than 20" << std::endl;
+    }
+
+    if i is in(10,30) {
+        std::cout << "i is between 10 and 30" << std::endl;
+    }
+
+    v : std::vector<int> = ();
+
+    if empty(v) {
+        std::cout << "v is empty" << std::endl;
+    }
+
+    if v is (empty) {
+        std::cout << "v is empty" << std::endl;
+    }
+}

regression-tests/test-results/clang-12/mixed-inspect-values-2.cpp.execution

@@ -0,0 +1,5 @@
+i is between 11 and 20
+less than 20
+i is between 10 and 30
+v is empty
+v is empty

regression-tests/test-results/clang-12/mixed-inspect-values-2.cpp.output

@@ -0,0 +1,5 @@
+i is between 11 and 20
+less than 20
+i is between 10 and 30
+v is empty
+v is empty

regression-tests/test-results/gcc-10/mixed-inspect-values-2.cpp.execution

@@ -0,0 +1,56 @@
+// ----- Cpp2 support -----
+#include "cpp2util.h"
+
+#line 1 "mixed-inspect-values-2.cpp2"
+
+#include <iostream>
+#include <vector>
+
+constexpr auto less_then = [](int value) {
+    return [=](auto x) { return x < value;};
+};
+
+constexpr auto in = [](auto min, auto max) {
+    return [=](auto x) {
+        return min <= x && x <= max;
+    };
+};
+
+constexpr auto empty = [](auto&& x){
+    return std::empty(x);
+};
+
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 18 "mixed-inspect-values-2.cpp2"
+
+[[nodiscard]] auto main() -> int{
+    auto i { 15 }; 
+
+    std::cout << [&] () -> std::string { auto&& __expr = i;
+        if (cpp2::is(__expr, (less_then(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
+        else return "i is out of our interest"; }
+    () << std::endl;
+
+    if (cpp2::is(i, less_then(20))) {
+        std::cout << "less than 20" << std::endl;
+    }
+
+    if (cpp2::is(std::move(i), in(10, 30))) {
+        std::cout << "i is between 10 and 30" << std::endl;
+    }
+
+    std::vector<int> v {  }; 
+
+    if (empty(v)) {
+        std::cout << "v is empty" << std::endl;
+    }
+
+    if (cpp2::is(std::move(v), (empty))) {
+        std::cout << "v is empty" << std::endl;
+    }
+}
+

regression-tests/test-results/gcc-10/mixed-inspect-values-2.cpp.output

@@ -0,0 +1,2 @@
+mixed-inspect-values-2.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks)
+

regression-tests/test-results/mixed-inspect-values-2.cpp

@@ -47,11 +47,11 @@ auto test(auto const& x) -> void{
     std::cout << [&] () -> std::string { auto&& __expr = x;
         if (cpp2::is(__expr, 0)) { if constexpr( requires{"zero";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("zero")),std::string> ) return "zero"; else return std::string{}; else return std::string{}; }
         else if (cpp2::is(__expr, (in(1, 2)))) { if constexpr( requires{"1 or 2";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("1 or 2")),std::string> ) return "1 or 2"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, (in_2_3))) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, (std::move(forty_two)))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(__expr, in_2_3)) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(__expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
         else if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); else return std::string{}; else return std::string{}; }
         else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); else return std::string{}; else return std::string{}; }
         else return "(no match)"; }
-    ()
- << "\n";}
+    () << "\n";
+}
 

regression-tests/test-results/mixed-inspect-values-2.cpp2.output

@@ -20,8 +20,8 @@ auto calc() {
     return [&] () -> int { auto&& __expr = v;
         if (cpp2::is<int>(__expr)) { if constexpr( requires{calc<1,2>();} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((calc<1,2>())),int> ) return calc<1,2>(); else return int{}; else return int{}; }
         else return 0; }
-    ()
-; }
+    (); 
+}
 
 [[nodiscard]] auto main() -> int{
     return fun(42); 

regression-tests/test-results/mixed-inspect-values.cpp

@@ -0,0 +1,5 @@
+i is between 11 and 20
+less than 20
+i is between 10 and 30
+v is empty
+v is empty

regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp

@@ -0,0 +1 @@
+mixed-inspect-values-2.cpp

regression-tests/test-results/msvc-2022/mixed-inspect-values-2.cpp.execution

@@ -38,7 +38,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
             if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + std::to_string(cpp2::as<int>(x)))),std::string> ) return "integer " + std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
             else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{'"' + cpp2::as<std::string>(x) + '"';} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(('"' + cpp2::as<std::string>(x) + '"')),std::string> ) return '"' + cpp2::as<std::string>(x) + '"'; else return std::string{}; else return std::string{}; }
             else return "not an int or string"; }
-        ()
+        () 
         << "\n";
 }
 

regression-tests/test-results/msvc-2022/mixed-inspect-values-2.cpp.output

@@ -24,7 +24,7 @@ auto print_an_int(auto const& x) -> void{
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
             else return "not an int"; }
-        ()
+        () 
         << "\n";
 }
 

regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp

@@ -33,7 +33,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
             else if (cpp2::is<std::any>(__expr)) { if constexpr( requires{" matches std::any";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::any")),std::string> ) return " matches std::any"; else return std::string{}; else return std::string{}; }
             else if (cpp2::is<std::optional<std::string>>(__expr)) { if constexpr( requires{" matches std::optional<std::string>";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::optional<std::string>")),std::string> ) return " matches std::optional<std::string>"; else return std::string{}; else return std::string{}; }
             else return " no match"; }
-        ()
+        () 
         << "\n";
 }
 

regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp

@@ -34,7 +34,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<void>(__expr)) { if constexpr( requires{" VOYDE AND EMPTIE";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" VOYDE AND EMPTIE")),std::string> ) return " VOYDE AND EMPTIE"; else return std::string{}; else return std::string{}; }
             else return " no match"; }
-        ()
+        () 
         << "\n";
 }
 

regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp

@@ -37,7 +37,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); else return std::string{}; else return std::string{}; }
             else return "not an int"; }
-        ()
+        () 
         << "\n";
 }
 

regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp

@@ -1383,7 +1383,7 @@ class cppfront
         if (is_expression) {
             printer.print_cpp2("()", n.close_brace);
         }
-        printer.print_cpp2("\n", n.close_brace);
+        //printer.print_cpp2("\n", n.close_brace);
     }
 
 
@@ -1972,24 +1972,59 @@ class cppfront
 
         //  Handle is/as expressions
         //  TODO: Generalize
-        if (!n.terms.empty() && *n.terms.front().op == "is")
+
+        //  If this is an is_as_expression_node
+        //
+        if constexpr (std::is_same_v<is_as_expression_node const&, decltype(n)>)
         {
-            if (n.terms.size() > 1) {
-                errors.emplace_back(
-                    n.position(),
-                    "(temporary alpha limitation) this compiler is just starting to learn 'is' and only supports a single is-expression (no chaining with other is/as)"
-                );
-                return;
-            }
+            if (!n.terms.empty() && *n.terms.front().op == "is")
+            {
+                if (n.terms.size() > 1) {
+                    errors.emplace_back(
+                        n.position(),
+                        "(temporary alpha limitation) this compiler is just starting to learn 'is' and only supports a single is-expression (no chaining with other is/as)"
+                    );
+                    return;
+                }
 
-            printer.print_cpp2("cpp2::is<", n.position());
-            emit(*n.terms.front().expr);
-            printer.print_cpp2(">(", n.position());
+                //  The term will be a prefix_expression_node
+                auto prefix_expr = n.terms.front().expr.get();
+                assert (prefix_expr);
+                static_assert (std::is_same_v<prefix_expression_node*, decltype(prefix_expr)>);
+
+                //  In the future we'll distinguish type_id better, but for now
+                //  "identifier or id_expression w/o ops" works well enough
+                //
+                //  If it's "is type", emit "cpp2::is<type>(expr)"
+                if (prefix_expr->ops.empty() &&         // no prefix ops
+                    prefix_expr->expr->ops.empty() &&   // no postfix ops
+                    (prefix_expr->expr->expr->expr.index() == primary_expression_node::identifier ||
+                     prefix_expr->expr->expr->expr.index() == primary_expression_node::id_expression
+                     )
+                    )
+                {
+                    printer.print_cpp2("cpp2::is<", n.position());
+                    emit(*n.terms.front().expr);
+                    printer.print_cpp2(">(", n.position());
 
-            emit(*n.expr);
+                    emit(*n.expr);
 
-            printer.print_cpp2(")", n.position());
-            return;
+                    printer.print_cpp2(")", n.position());
+                }
+                //  Else it's "is value", emit "cpp2::is(expr, value)"
+                else
+                {
+                    printer.print_cpp2("cpp2::is(", n.position());
+
+                    emit(*n.expr);
+
+                    printer.print_cpp2(", ", n.position());
+                    emit(*n.terms.front().expr);
+                    printer.print_cpp2(")", n.position());
+                }
+
+                return;
+            }
         }
 
         if (!n.terms.empty() && *n.terms.front().op == "as")