Start initial name: as id-expression inspect alternative support

And make the 'todo' grammar comments clearer

Author: hsutter

README.md

@@ -128,7 +128,7 @@ For now, I'm not posting a lot of written documentation because that would imply
 
 Here's where to find out more about my 'syntax #2' experiment:
 
-- **My CppCon 2022 talk** [link coming soon] — this is the primary documentation right now. See also every talk I've given and paper I've written since 2015, each of which details an individual part of this design experiment, but presented in today's C++ syntax as a standalone C++ evolution proposal.
+- **My CppCon 2022 talk, "C++ simplicity, safety, and toolability: Can C++ be 10x simpler and safer ...?**" [link coming soon] — this is the primary documentation right now. See also every talk I've given and paper I've written since 2015, each of which details an individual part of this design experiment, but presented in today's C++ syntax as a standalone C++ evolution proposal.
 - **The [cppfront regression tests](https://github.com/hsutter/cppfront/tree/main/regression-tests/test-results)** which show dozens of working examples, each with a`.cpp2` file and the `.cpp` file it is translated to. Each filename briefly describes the language features the test demonstrates (e.g., contracts, parameter passing, bounds safety, type-safe `is` queries and `as` casts, initialization safety, and generalized value capture including in function expressions ('lambdas'), postconditions, and string interpolation).
 
 ## List of my papers and talks since 2015 (all from this work, but presented in today's syntax)
@@ -233,8 +233,8 @@ Cppfront currently has basic support for `is` and `as`, including for dynamic ty
 I still need to validate the `is` and `as` implementations with more cases (I'm sure there are still some that break that I need to fix), flesh out allowing `is` and `as` in `requires`-clauses to constrain templates (as shown in the paper), and non-basic `inspect` pattern matching examples.
 
 ### 2022: CppCon 2022 talk and cppfront
-    
-- **CppCon 2022**: "Can C++ be 10x simpler & safer?" (link coming soon).
+
+- **CppCon 2022**: "C++ simplicity, safety, and toolability: Can C++ be 10x simpler and safer ...?" [link coming soon]
 - This repo.
 
 # Epilog: 2016 roadmap diagram

source/cppfront.cpp

@@ -1192,7 +1192,7 @@ class cppfront
 
         for (auto first = true; auto&& alt : n.alternatives)
         {
-            assert(alt);
+            assert(alt && alt->is_as_keyword);
             if (!first) {
                 printer.print_cpp2("else ", alt->position());
             }
@@ -1204,7 +1204,10 @@ class cppfront
             emit(*alt->id_expression);
             printer.emit_to_string();
 
-            if (*alt->identifier == "is")
+            assert (*alt->is_as_keyword == "is" || *alt->is_as_keyword == "as");
+            // TODO: pick up 'as' next, for now just do 'is'
+
+            if (*alt->is_as_keyword == "is")
             {
                 //  Stringize the expression-statement now...
                 auto statement = std::string{};

source/lex.h

@@ -667,8 +667,8 @@ auto lex_line(
             //G     character-literal
             //G     floating-point-literal
             //G     string-literal
-            //GT     boolean-literal
-            //GT     pointer-literal
+            //GTODO     boolean-literal
+            //GTODO     pointer-literal
             //G
             //G integer-literal:
             //G     binary-literal
@@ -728,7 +728,7 @@ auto lex_line(
                 //G     
                 //G floating-point-literal:
                 //G     digit { ' | digit }* . digit { ' | digit }*
-                //GT TODO: full grammar
+                //GTODO TODO: full grammar
                 //G     
                 else if (is_digit(line[i])) {
                     auto j = 1;

source/parse.h

@@ -597,15 +597,16 @@ struct return_statement_node
 
 struct alternative_node
 {
-    token const*                        identifier;
-    std::unique_ptr<id_expression_node> id_expression;
-    source_position                     equal_sign;
-    std::unique_ptr<statement_node>     statement;
+    std::unique_ptr<unqualified_id_node> name;
+    token const*                         is_as_keyword;
+    std::unique_ptr<id_expression_node>  id_expression;
+    source_position                      equal_sign;
+    std::unique_ptr<statement_node>      statement;
 
     auto position() const -> source_position
     {
-        assert(identifier);
-        return identifier->position();
+        assert(is_as_keyword);
+        return is_as_keyword->position();
     }
 
     auto visit(auto& v, int depth) -> void;
@@ -708,8 +709,11 @@ struct statement_node
 auto alternative_node::visit(auto& v, int depth) -> void
 {
     v.start(*this, depth);
-    assert (identifier);
-    v.start(*identifier, depth+1);
+    if (name) {
+        v.start(*name, depth+1);
+    }
+    assert (is_as_keyword);
+    v.start(*is_as_keyword, depth+1);
     assert (id_expression);
     id_expression->visit(v, depth+1);
     assert (statement);
@@ -1458,11 +1462,11 @@ class parser
     //G prefix-expression:
     //G     postfix-expression
     //G     prefix-operator prefix-expression
-    //GT     await-expression
-    //GT     sizeof ( type-id )
-    //GT     sizeof ... ( identifier )
-    //GT     alignof ( type-id )
-    //GT     throws-expression
+    //GTODO     await-expression
+    //GTODO     sizeof ( type-id )
+    //GTODO     sizeof ... ( identifier )
+    //GTODO     alignof ( type-id )
+    //GTODO     throws-expression
     //G
     auto prefix_expression() 
         -> std::unique_ptr<prefix_expression_node>
@@ -1516,9 +1520,9 @@ class parser
 
     //G is-as-expression:
     //G     prefix-expression 
-    //GT    is-as-expression is-expression-constraint
-    //GT    is-as-expression as-type-cast
-    //GT    type-id is-type-constraint
+    //GTODO    is-as-expression is-expression-constraint
+    //GTODO    is-as-expression as-type-cast
+    //GTODO    type-id is-type-constraint
     //G
     auto is_as_expression() {
         return binary_expression<is_as_expression_node> (
@@ -1682,7 +1686,7 @@ class parser
 
     //G  expression:                // eliminated condition: - use expression:
     //G     assignment-expression
-    //GT    try expression
+    //GTODO    try expression
     //G
     auto expression(bool allow_relational_comparison = true) -> std::unique_ptr<expression_node> {
         auto n = std::make_unique<expression_node>();
@@ -1744,7 +1748,7 @@ class parser
     //G unqualified-id:
     //G     const-opt identifier
     //G     const-opt template-id
-    //GT     operator-function-id
+    //GTODO     operator-function-id
     //G
     //G template-id:
     //G     identifier < template-argument-list-opt >
@@ -2180,21 +2184,46 @@ class parser
 
 
     //G alternative:
-    //G     is-expression-constraint = statement
+    //G     alt-name-opt is-type-constraint = statement
+    //G     alt-name-opt as-type-cast = statement
+    //GTODO    alt-name-opt is-expression-constraint = statement
     //G
-    //G is-expression-constraint
+    //G is-type-constraint
     //G     is id-expression
     //G
+    //G as-type-cast
+    //G     as id-expression
+    //G
+    //G alt-name:
+    //G     unqualified-id :
+    //G
     auto alternative() -> std::unique_ptr<alternative_node> 
     {
-        //  Initial partial implementation: Just "is id-expression"
-        //  (note: that covers "_" as an unqualified-id)
-        if (curr() != "is") {
+        auto n = std::make_unique<alternative_node>();
+
+        ////  Check for an optional name (just one unqualified-id, no decomposition yet)
+        //if (curr() != "is" && curr() != "as") {
+        //    if (auto id = unqualified_id()) {
+        //        n->name = std::move(id);
+        //    }
+        //    else {
+        //        error("expected unqualified-id, 'is', or 'as' to start an inspect alternative");
+        //        return {};
+        //    }
+        //    if (curr().type() != lexeme::Colon) {
+        //        error("expected : after the introduced name in an inspect alternative");
+        //        return {};
+        //    }
+        //    next();
+        //}
+        
+        //  Now we should be as "is" or "as"
+        //  (initial partial implementation, just "is/as id-expression")
+        if (curr() != "is" && curr() != "as") {
             return {};
         }
 
-        auto n = std::make_unique<alternative_node>();
-        n->identifier = &curr();
+        n->is_as_keyword = &curr();
         next();
 
         if (auto id = id_expression()) {
@@ -2325,8 +2354,8 @@ class parser
     //G     inspect-expression
     //G     let parameter-list statement
     // 
-    //GT     jump-statement
-    //GT     try-block
+    //GTODO     jump-statement
+    //GTODO     try-block
     //G
     auto statement(bool semicolon_required, source_position equal_sign = source_position{})
         -> std::unique_ptr<statement_node>