Add support for inspecting values (not just types), closes #79

Also cleaned up _alternative_ to use _type-id_ rather than _id-expression_.

Author: hsutter

include/cpp2util.h

@@ -616,6 +616,23 @@ auto is( X const& x ) -> bool {
 }
 
 
+//-------------------------------------------------------------------------------------------------------------
+//  Built-in is (values)
+//
+
+inline constexpr auto is( auto const& x, auto const& value ) -> bool
+    requires requires{ x == value; }
+{
+    return x == value;
+}
+
+inline constexpr auto is( auto const& x, auto const& value ) -> bool
+    requires (!requires{ x == value; })
+{
+    return false;
+}
+
+
 //-------------------------------------------------------------------------------------------------------------
 //  Built-in as (partial)
 //

regression-tests/pure2-inspect-values.cpp2

@@ -0,0 +1,18 @@
+main: ()->int = {
+    test(42);
+    test(3.14);
+    test(0);
+    test(-42);
+    test("xyzzy" as std::string);
+}
+
+test: (x:_) = {
+    forty_two := 42;
+    std::cout << inspect x -> std::string {
+        is 0           = "zero";
+        is (forty_two) = "the answer";
+        is int         = "integer " + cpp2::to_string(x);
+        is std::string = x;
+        is _           = "(no match)";
+    } << "\n";
+}

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

@@ -0,0 +1,5 @@
+the answer
+(no match)
+zero
+integer -42
+xyzzy

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

@@ -0,0 +1,5 @@
+the answer
+(no match)
+zero
+integer -42
+xyzzy

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

@@ -0,0 +1,5 @@
+the answer
+(no match)
+zero
+integer -42
+xyzzy

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

@@ -0,0 +1 @@
+pure2-inspect-values.cpp

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

@@ -0,0 +1,32 @@
+// ----- Cpp2 support -----
+#define CPP2_USE_MODULES         Yes
+#include "cpp2util.h"
+
+
+#line 1 "pure2-inspect-values.cpp2"
+[[nodiscard]] auto main() -> int;
+#line 9 "pure2-inspect-values.cpp2"
+auto test(auto const& x) -> void;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 1 "pure2-inspect-values.cpp2"
+[[nodiscard]] auto main() -> int{
+    test(42);
+    test(3.14);
+    test(0);
+    test(-42);
+    test(cpp2::as<  std::string>("xyzzy"));
+}
+
+auto test(auto const& x) -> void{
+    auto forty_two { 42 }; 
+    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, (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{x;} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((x)),std::string> ) return x; else return std::string{}; else return std::string{}; }
+        else return "(no match)"; }
+    ()
+ << "\n";}
+

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

@@ -0,0 +1,2 @@
+pure2-inspect-values.cpp2... ok (all Cpp2, passes safety checks)
+

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

@@ -1294,8 +1294,14 @@ class cppfront
 
             auto id = std::string{};
             printer.emit_to_string(&id);
-            assert(alt->id_expression);
-            emit(*alt->id_expression);
+
+            if (alt->type_id) {
+                emit(*alt->type_id);
+            }
+            else {
+                assert(alt->value);
+                emit(*alt->value);
+            }
             printer.emit_to_string();
 
             assert (*alt->is_as_keyword == "is" || *alt->is_as_keyword == "as");
@@ -1330,7 +1336,15 @@ class cppfront
                     }
                 }
                 else {
-                    printer.print_cpp2("if " + constexpr_qualifier + "(cpp2::is<" + id + ">(__expr)) " + return_prefix, alt->position());
+                    printer.print_cpp2("if " + constexpr_qualifier, alt->position());
+                    if (alt->type_id) {
+                        printer.print_cpp2("(cpp2::is<" + id + ">(__expr)) ", alt->position());
+                    }
+                    else {
+                        assert (alt->value);
+                        printer.print_cpp2("(cpp2::is(__expr, " + id + ")) ", alt->position());
+                    }
+                    printer.print_cpp2(return_prefix, alt->position());
                 }
 
                 printer.print_cpp2(statement, alt->position());

regression-tests/test-results/pure2-inspect-values.cpp2.output

@@ -664,7 +664,11 @@ struct alternative_node
 {
     std::unique_ptr<unqualified_id_node> name;
     token const*                         is_as_keyword;
-    std::unique_ptr<id_expression_node>  id_expression;
+
+    //  One of these will be used
+    std::unique_ptr<type_id_node>            type_id;
+    std::unique_ptr<postfix_expression_node> value;
+
     source_position                      equal_sign;
     std::unique_ptr<statement_node>      statement;
 
@@ -776,8 +780,13 @@ auto alternative_node::visit(auto& v, int depth) -> void
     }
     assert (is_as_keyword);
     v.start(*is_as_keyword, depth+1);
-    assert (id_expression);
-    id_expression->visit(v, depth+1);
+    if (type_id) {
+        type_id->visit(v, depth+1);
+    }
+    else {
+        assert (value);
+        value->visit(v, depth+1);
+    }
     assert (statement);
     statement->visit(v, depth+1);
     v.end(*this, depth);
@@ -1785,7 +1794,7 @@ class parser
     }
 
     //G expression-list:
-    //G     expression
+    //G     parameter-direction-opt expression
     //G     expression-list , expression
     //G
     auto expression_list(source_position open_paren, bool inside_initializer = false) -> std::unique_ptr<expression_list_node> {
@@ -2302,11 +2311,15 @@ class parser
 
     //G alternative:
     //G     alt-name-opt is-type-constraint = statement
+    //G     alt-name-opt is-value-constraint = statement
     //G     alt-name-opt as-type-cast = statement
     //GTODO    alt-name-opt is-expression-constraint = statement
     //G
     //G is-type-constraint
-    //G     is id-expression
+    //G     is type-id
+    //G
+    //G is-value-constraint
+    //G     is postfix-expression
     //G
     //G as-type-cast
     //G     as id-expression
@@ -2343,11 +2356,14 @@ class parser
         n->is_as_keyword = &curr();
         next();
 
-        if (auto id = id_expression()) {
-            n->id_expression = std::move(id);
+        if (auto id = type_id()) {
+            n->type_id = std::move(id);
+        }
+        else if (auto e = postfix_expression()) {
+            n->value = std::move(e);
         }
         else {
-            error("expected id-expression after 'is' in inspect alternative");
+            error("expected type-id or value after 'is' in inspect alternative");
             return {};
         }