Synthesize >= the same as we already do >> and >>=

Closes #1162

This synthesizes>>= in relational-expression, the same way we already do for >> in shift-expression and >>= in assignment-expression

This allows code like `x: std::vector<int>=(1,2,3);` without the spaces, and avoids max munch misinterpreting the >= as a single token

Author: hsutter

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.7.1   Build 9714:0930
+cppfront compiler v0.7.1   Build 9715:1523
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"9714:0930"
+"9715:1523"

source/lex.h

@@ -1352,7 +1352,7 @@ auto lex_line(
                 }
                 else { store(1, lexeme::Less); }
 
-            //  Note: >> and >>= are not source tokens, they are synthesized from > > and > >= where legal
+            //  Note: >= and >> and >>= synthesized from > = and > > and > >= where legal
             //G     '>>=' '>>' '>=' '>'
             break;case '>':
                 //---------------------------------------------------------
@@ -1362,10 +1362,10 @@ auto lex_line(
                 //    if (peek2 == '=') { store(3, lexeme::RightShiftEq); }
                 //    else { store(2, lexeme::RightShift); }
                 //}
+                //else if (peek1 == '=') { store(2, lexeme::GreaterEq); }
                 //else
                 //---------------------------------------------------------
-                if (peek1 == '=') { store(2, lexeme::GreaterEq); }
-                else { store(1, lexeme::Greater); }
+                { store(1, lexeme::Greater); }
 
             //G     '++' '+=' '+'
             break;case '+':

source/parse.h

@@ -6157,6 +6157,26 @@ class parser
                     next();
                 }
 
+                //  And for assignment-expression we may synthesize >>= from > > =
+                //  which will return a token* == a valid operator for this production
+                //  (possibly a synthesized new token) or nullptr otherwise
+                else if constexpr (requires{ validate_op(curr(), *peek(1), *peek(2)); }) {
+                    if (
+                        peek(1) == nullptr
+                        || peek(2) == nullptr
+                        || (t.op = validate_op(curr(), *peek(1), *peek(2))) == nullptr
+                        )
+                    {
+                        break;
+                    }
+                    //  If we didn't consume the next token, we consumed the next three
+                    if (t.op != &curr()) {
+                        next();
+                        next();
+                    }
+                    next();
+                }
+
                 //  And it shouldn't be anything else
                 else {
                     assert (!"ICE: validate_op should take one token and return bool, or two tokens and return token const* ");
@@ -6269,12 +6289,20 @@ class parser
     {
         if (allow_angle_operators) {
             return binary_expression<relational_expression_node> (
-                [](token const& t, token const& next) -> token const* {
+                [this](token const& t, token const& next) -> token const* {
+                    if (
+                        t.type() == lexeme::Greater
+                        && next.type() == lexeme::Assignment
+                        && t.position() == source_position{ next.position().lineno, next.position().colno - 1 }
+                        )
+                    {
+                        generated_tokens->emplace_back(">=", t.position(), lexeme::GreaterEq);
+                        return &generated_tokens->back();
+                    }
                     if (
                         t.type() == lexeme::Less
                         || t.type() == lexeme::LessEq
-                        || (t.type() == lexeme::Greater && next.type() != lexeme::GreaterEq)
-                        || t.type() == lexeme::GreaterEq
+                        || t.type() == lexeme::Greater
                         ) {
                         return &t;
                     }
@@ -6394,13 +6422,14 @@ class parser
         if (allow_angle_operators)
         {
             ret = binary_expression<assignment_expression_node> (
-                [this](token const& t, token const& next) -> token const* {
+                [this](token const& t, token const& next, token const& third) -> token const* {
                     if (is_assignment_operator(t.type())) {
                         return &t;
                     }
                     if (
                         t.type() == lexeme::Greater
-                        && next.type() == lexeme::GreaterEq
+                        && next.type() == lexeme::Greater
+                        && third.type() == lexeme::Assignment
                         && t.position() == source_position{ next.position().lineno, next.position().colno-1 }
                         )
                     {