Generalize _is-as-expression_ and _type-id_

- Allow multiple consecutive `as`
- Correctly distinguish 'is/as Type' and 'is expression'
- Treat C/C++'s built-in keyword types as type-ids (e.g., `int`) and recognize them in _type-id_ and not in _primary-expression_
- Treat C/C++'s built-in keyword quasi-identifiers are non-keywords (`false,` `new`, `nullptr`, `true`)
- Switch to _type-id_ in _unqualified-id_ and , where before we were still having _id-expression_ doing double duty as an early grammar shortcut

Author: hsutter

include/cpp2util.h

@@ -248,7 +248,7 @@ class contract_group {
 public:
     using handler = void (*)(CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM);
 
-    constexpr contract_group  (handler h = nullptr)  : reporter(h) { }
+    constexpr contract_group  (handler h = {})  : reporter(h) { }
     constexpr auto set_handler(handler h) -> handler;
     constexpr auto get_handler() const    -> handler { return reporter; }
     constexpr auto expects    (bool b, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT)
@@ -417,7 +417,7 @@ class out {
         T* t;
         deferred_init<T>* dt;
     };
-    out<T>* ot = nullptr;
+    out<T>* ot = {};
     bool has_t;
 
     //  Each out in a chain contains its own uncaught_count ...

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

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <vector>
 
-constexpr auto less_then = [](int value) {
+constexpr auto less_than = [](int value) {
     return [=](auto x) { return x < value;};
 };
 
@@ -20,16 +20,16 @@ main: () -> int = {
     i := 15;
 
     std::cout << inspect i -> std::string {
-        is (less_then(10)) = "i less than 10";
+        is (less_than(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) {
+    if i is (less_than(20)) {
         std::cout << "less than 20" << std::endl;
     }
 
-    if i is in(10,30) {
+    if i is (in(10,30)) {
         std::cout << "i is between 10 and 30" << std::endl;
     }
 

regression-tests/pure2-ufcs-member-access-and-chaining.cpp2

@@ -14,9 +14,9 @@ main: () -> int = {
 
     get_i(fun()).ufcs();
 
-    res := int(42).ufcs();
+    res := (42).ufcs();
 
-    int(j.i).ufcs();
+    (j.i).ufcs();
 }
 
 ufcs: (i:int) -> int = {

regression-tests/test-results/mixed-forwarding.cpp

@@ -40,8 +40,8 @@ requires std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>
 auto apply_explicit_forward(auto&& t) -> void
 requires std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>
 #line 21 "mixed-forwarding.cpp2"
-{   copy_from(CPP2_FORWARD(t).first);// moves
-    copy_from(CPP2_FORWARD(t).second);// moves
+{   copy_from(        CPP2_FORWARD(t).first);// moves
+    copy_from(        CPP2_FORWARD(t).second);// moves
 }
 
 [[nodiscard]] auto main() -> int{

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

@@ -6,7 +6,7 @@
 #include <iostream>
 #include <vector>
 
-constexpr auto less_then = [](int value) {
+constexpr auto less_than = [](int value) {
     return [=](auto x) { return x < value;};
 };
 
@@ -30,16 +30,16 @@ constexpr auto empty = [](auto&& x){
     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{}; }
+        if (cpp2::is(__expr, (less_than(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))) {
+    if (cpp2::is(i, (less_than(20)))) {
         std::cout << "less than 20" << std::endl;
     }
 
-    if (cpp2::is(std::move(i), in(10, 30))) {
+    if (cpp2::is(std::move(i), (in(10, 30)))) {
         std::cout << "i is between 10 and 30" << std::endl;
     }
 

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

@@ -30,15 +30,15 @@ auto test(auto const& x) -> void;
 
     std::any a { 0 }; 
     test(a);
-    a = cpp2::as<  std::string>("plugh");
+    a = cpp2::as<std::string>("plugh");
     test(std::move(a));
 
     test(0);
     test(1);
     test(2);
     test(3);
     test(-42);
-    test(cpp2::as<  std::string>("xyzzy"));
+    test(cpp2::as<std::string>("xyzzy"));
     test(3.14);
 }
 

regression-tests/test-results/pure2-ufcs-member-access-and-chaining.cpp

@@ -35,9 +35,9 @@ struct fun__ret {
 
     CPP2_UFCS_0(ufcs, get_i(fun()));
 
-    auto res { CPP2_UFCS_0(ufcs, int(42)) }; 
+    auto res { CPP2_UFCS_0(ufcs, 42) }; 
 
-    CPP2_UFCS_0(ufcs, int(std::move(j).i));
+    CPP2_UFCS_0(ufcs, (std::move(j).i));
 }
 
 [[nodiscard]] auto ufcs(cpp2::in<int> i) -> int{

source/common.h

@@ -432,7 +432,7 @@ class cmdline_processor
         }
     }
     struct register_flag {
-        register_flag(int group, std::string_view name, std::string_view description, callback0 handler0, callback1 handler1 = nullptr, std::string_view synonym = {}, bool opt_out = false);
+        register_flag(int group, std::string_view name, std::string_view description, callback0 handler0, callback1 handler1 = {}, std::string_view synonym = {}, bool opt_out = false);
     };
 
     auto set_args(int argc, char* argv[]) -> void {

source/cppfront.cpp

@@ -598,7 +598,7 @@ class positional_printer
     //  Provide an option to store to a given string instead, which is
     //  useful for capturing Cpp1-formatted output for generated code
     //
-    auto emit_to_string( std::string* target = nullptr ) -> void {
+    auto emit_to_string( std::string* target = {} ) -> void {
         if (target) {
             emit_string_targets.push_back( target );
             emit_target_stack.push_back(target_type::string);
@@ -613,7 +613,7 @@ class positional_printer
     //  useful for postfix expression which have to mix unwrapping operators
     //  with emitting sub-elements such as expression lists
     //
-    auto emit_to_text_chunks( std::vector<text_with_pos>* target = nullptr ) -> void {
+    auto emit_to_text_chunks( std::vector<text_with_pos>* target = {} ) -> void {
         if (target) {
             emit_text_chunks_targets.push_back( target );
             emit_target_stack.push_back(target_type::chunks);
@@ -653,7 +653,7 @@ class cppfront
 
     struct arg_info {
         passing_style pass   = passing_style::in;
-        token const*  ptoken = nullptr;
+        token const*  ptoken = {};
     };
     std::vector<arg_info> current_args  = { {} };
 
@@ -913,6 +913,14 @@ class cppfront
     //  is needed where Cpp1 and Cpp2 have different grammar orders
     //
 
+    auto print_to_string(auto& i, auto... more) -> std::string {
+        auto print = std::string{};
+        printer.emit_to_string(&print);
+        emit(i, more...);
+        printer.emit_to_string();
+        return print;
+    };
+
     //-----------------------------------------------------------------------
     //  try_emit
     //
@@ -1120,8 +1128,8 @@ class cppfront
                     printer.print_cpp2(",", a.comma);
                 }
                 first = false;
-                try_emit<unqualified_id_node::expression   >(a.arg);
-                try_emit<unqualified_id_node::id_expression>(a.arg);
+                try_emit<unqualified_id_node::expression>(a.arg);
+                try_emit<unqualified_id_node::type_id   >(a.arg);
             }
             printer.print_cpp2(">", n.close_angle);
         }
@@ -1188,6 +1196,7 @@ class cppfront
     {
         try_emit<type_id_node::qualified  >(n.id);
         try_emit<type_id_node::unqualified>(n.id, false, false);
+        try_emit<type_id_node::keyword    >(n.id);
 
         for (auto i = n.pc_qualifiers.rbegin(); i != n.pc_qualifiers.rend(); ++i) {
             if ((**i) == "const") { printer.print_cpp2(" ", n.position()); }
@@ -1754,13 +1763,6 @@ class cppfront
             }
         };
 
-        auto print_to_string = [&](auto& i, auto... more) {
-            auto print = std::string{};
-            printer.emit_to_string(&print);
-            emit(i, more...);
-            printer.emit_to_string();
-            return print;
-        };
         auto print_to_text_chunks = [&](auto& i, auto... more) {
             auto text = std::vector<text_with_pos>{};
             printer.emit_to_text_chunks(&text);
@@ -1983,90 +1985,43 @@ class cppfront
 
     //-----------------------------------------------------------------------
     //
-    template<
-        String   Name,
-        typename Term
-    >
-    auto emit(binary_expression_node<Name,Term> const& n) -> void
+    auto emit(is_as_expression_node const& n) -> void
     {
-        assert(n.expr);
-
-        //  Handle is/as expressions
-        //  TODO: Generalize
+        std::string prefix = {};
+        std::string suffix = {};
 
-        //  If this is an is_as_expression_node
-        //
-        if constexpr (std::is_same_v<is_as_expression_node const&, decltype(n)>)
+        for (auto i = n.ops.rbegin(); i != n.ops.rend(); ++i)
         {
-            if (!n.terms.empty() && *n.terms.front().op == "is")
+            //  If it's "ISORAS type", emit "cpp2::ISORAS<type>(expr)"
+            if (i->type)
             {
-                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;
-                }
-
-                //  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)>);
-
-                //  Hack: 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);
-
-                    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;
+                prefix += "cpp2::" + i->op->to_string(true) + "<" + print_to_string(*i->type) + ">(";
+                suffix = ")" + suffix;
+            }
+            //  Else it's "is value", emit "cpp2::is(expr, value)"
+            else
+            {
+                assert(i->expr);
+                prefix += "cpp2::" + i->op->to_string(true) + "(";
+                suffix = ", " + print_to_string(*i->expr) + ")" + suffix;
             }
         }
 
-        if (!n.terms.empty() && *n.terms.front().op == "as")
-        {
-            if (n.terms.size() > 1) {
-                errors.emplace_back(
-                    n.position(),
-                    "(temporary alpha limitation) this compiler is just starting to learn 'as' and only supports a single as-expression (no chaining with other is/as)"
-                );
-                return;
-            }
+        printer.print_cpp2(prefix, n.position());
+        emit(*n.expr);
+        printer.print_cpp2(suffix, n.position());
+    }
 
-            printer.print_cpp2("cpp2::as<", n.position());
-            emit(*n.terms.front().expr);
-            printer.print_cpp2(">(", n.position());
 
-            emit(*n.expr);
-
-            printer.print_cpp2(")", n.position());
-            return;
-        }
+    //-----------------------------------------------------------------------
+    //
+    template<
+        String   Name,
+        typename Term
+    >
+    auto emit(binary_expression_node<Name,Term> const& n) -> void
+    {
+        assert(n.expr);
 
         //  If this is an assignment expression, don't add std::move on the lhs
         //  even if this is a definite last use (only do that when an rvalue is okay)

source/lex.h

@@ -439,17 +439,17 @@ auto lex_line(
             "^co_yield|^concept|^const|^const_cast|^consteval|^constexpr|^constinit|^continue|"
             "^decltype|^default|^double|^do|^dynamic_cast|"
             "^else|^enum|^explicit|^export|^extern|"
-            "^false|^float|^for|^friend|"
+            "^float|^for|^friend|"
             "^goto|"
             "^if|^import|^inline|^int|^is|"
             "^long|"
             "^module|^mutable|"
-            "^namespace|^new|^noexcept|^nullptr|"
+            "^namespace|^noexcept|"
             "^operator|"
             "^private|^protected|^public|"
             "^register|^reinterpret_cast|^requires|^return|"
             "^short|^signed|^sizeof|^static|^static_assert|^static_cast|^struct|^switch|"
-            "^template|^this|^thread_local|^throws|^throw|^true|^try|^typedef|^typeid|^typename|"
+            "^template|^this|^thread_local|^throws|^throw|^try|^typedef|^typeid|^typename|"
             "^unsigned|^using|"
             "^virtual|^void|^volatile|"
             "^wchar_t|^while"