fix: Avoid splitting >= and >>= tokens

Author: robertoraggi

src/parser/cxx/lexer.cc

@@ -457,29 +457,20 @@ auto Lexer::readToken() -> TokenKind {
       return TokenKind::T_LESS;
 
     case '>':
-      if (preprocessing_) {
-        if (pos_ != end_ && LA() == '=') {
-          consume();
-          return TokenKind::T_GREATER_EQUAL;
-        }
-        if (pos_ != end_ && LA() == '>') {
+      if (pos_ != end_ && LA() == '=') {
+        consume();
+        return TokenKind::T_GREATER_EQUAL;
+      } else if (pos_ != end_ && LA() == '>') {
+        if (LA(1) == '=') {
+          consume(2);
+          return TokenKind::T_GREATER_GREATER_EQUAL;
+        } else if (preprocessing_) {
           consume();
-          if (pos_ != end_ && LA() == '=') {
-            consume();
-            return TokenKind::T_GREATER_GREATER_EQUAL;
-          }
           return TokenKind::T_GREATER_GREATER;
         }
-      } else if (LA() == '>') {
-        TokenKind k = TokenKind::T_GREATER_GREATER;
 
-        if (LA(1) == '=') k = TokenKind::T_GREATER_GREATER_EQUAL;
-
-        tokenValue_.tokenKindValue = k;
-      } else if (LA() == '=') {
-        tokenValue_.tokenKindValue = TokenKind::T_GREATER_EQUAL;
+        tokenValue_.tokenKindValue = TokenKind::T_GREATER_GREATER;
       }
-
       return TokenKind::T_GREATER;
 
     case '/': {

src/parser/cxx/parser.cc

@@ -112,7 +112,8 @@ void Parser::setCheckTypes(bool checkTypes) { checkTypes_ = checkTypes; }
 auto Parser::prec(TokenKind tk) -> Parser::Prec {
   switch (tk) {
     default:
-      cxx_runtime_error("expected a binary operator");
+      cxx_runtime_error(fmt::format("expected a binary operator, found {}",
+                                    Token::spell(tk)));
 
     case TokenKind::T_DOT_STAR:
     case TokenKind::T_MINUS_GREATER_STAR:
@@ -331,40 +332,6 @@ auto Parser::parse_greater_greater() -> bool {
   return false;
 }
 
-auto Parser::parse_greater_greater_equal() -> bool {
-  const auto saved = currentLocation();
-
-  SourceLocation greaterLoc;
-  SourceLocation secondGreaterLoc;
-  SourceLocation equalLoc;
-
-  if (match(TokenKind::T_GREATER, greaterLoc) && parse_nospace() &&
-      match(TokenKind::T_GREATER, secondGreaterLoc) && parse_nospace() &&
-      match(TokenKind::T_EQUAL, equalLoc)) {
-    return true;
-  }
-
-  rewind(saved);
-
-  return false;
-}
-
-auto Parser::parse_greater_equal() -> bool {
-  const auto saved = currentLocation();
-
-  SourceLocation greaterLoc;
-  SourceLocation equalLoc;
-
-  if (match(TokenKind::T_GREATER, greaterLoc) && parse_nospace() &&
-      match(TokenKind::T_EQUAL, equalLoc)) {
-    return true;
-  }
-
-  rewind(saved);
-
-  return false;
-}
-
 auto Parser::parse_header_name(SourceLocation& loc) -> bool {
   if (match(TokenKind::T_STRING_LITERAL, loc)) return true;
 
@@ -1298,21 +1265,11 @@ auto Parser::parse_fold_operator(SourceLocation& loc, TokenKind& op) -> bool {
 
   switch (TokenKind(LA())) {
     case TokenKind::T_GREATER: {
-      if (parse_greater_greater_equal()) {
-        op = TokenKind::T_GREATER_GREATER_EQUAL;
-        return true;
-      }
-
       if (parse_greater_greater()) {
         op = TokenKind::T_GREATER_GREATER;
         return true;
       }
 
-      if (parse_greater_equal()) {
-        op = TokenKind::T_GREATER_EQUAL;
-        return true;
-      }
-
       op = TokenKind::T_GREATER;
 
       consumeToken();
@@ -2492,11 +2449,6 @@ auto Parser::parse_binary_operator(SourceLocation& loc, TokenKind& tk,
         return true;
       }
 
-      if (parse_greater_equal()) {
-        tk = TokenKind::T_GREATER_EQUAL;
-        return true;
-      }
-
       if (exprContext.templArg || exprContext.templParam) {
         rewind(start);
         return false;
@@ -2507,24 +2459,25 @@ auto Parser::parse_binary_operator(SourceLocation& loc, TokenKind& tk,
       return true;
     }
 
-    case TokenKind::T_STAR:
-    case TokenKind::T_SLASH:
-    case TokenKind::T_PLUS:
-    case TokenKind::T_PERCENT:
-    case TokenKind::T_MINUS_GREATER_STAR:
-    case TokenKind::T_MINUS:
-    case TokenKind::T_LESS_LESS:
+    case TokenKind::T_AMP_AMP:
+    case TokenKind::T_AMP:
+    case TokenKind::T_BAR_BAR:
+    case TokenKind::T_BAR:
+    case TokenKind::T_CARET:
+    case TokenKind::T_DOT_STAR:
+    case TokenKind::T_EQUAL_EQUAL:
+    case TokenKind::T_EXCLAIM_EQUAL:
+    case TokenKind::T_GREATER_EQUAL:
     case TokenKind::T_LESS_EQUAL_GREATER:
     case TokenKind::T_LESS_EQUAL:
+    case TokenKind::T_LESS_LESS:
     case TokenKind::T_LESS:
-    case TokenKind::T_EXCLAIM_EQUAL:
-    case TokenKind::T_EQUAL_EQUAL:
-    case TokenKind::T_DOT_STAR:
-    case TokenKind::T_CARET:
-    case TokenKind::T_BAR_BAR:
-    case TokenKind::T_BAR:
-    case TokenKind::T_AMP_AMP:
-    case TokenKind::T_AMP:
+    case TokenKind::T_MINUS_GREATER_STAR:
+    case TokenKind::T_MINUS:
+    case TokenKind::T_PERCENT:
+    case TokenKind::T_PLUS:
+    case TokenKind::T_SLASH:
+    case TokenKind::T_STAR:
       tk = LA().kind();
       consumeToken();
       return true;
@@ -2728,13 +2681,6 @@ auto Parser::parse_assignment_operator(SourceLocation& loc, TokenKind& op)
       return true;
     }
 
-    case TokenKind::T_GREATER: {
-      loc = currentLocation();
-      if (!parse_greater_greater_equal()) return false;
-      op = TokenKind::T_GREATER_GREATER_EQUAL;
-      return true;
-    }
-
     default:
       return false;
   }  // switch
@@ -7540,18 +7486,10 @@ auto Parser::parse_operator(TokenKind& op, SourceLocation& opLoc,
 
     case TokenKind::T_GREATER: {
       opLoc = currentLocation();
-      if (parse_greater_greater_equal()) {
-        op = TokenKind::T_GREATER_GREATER_EQUAL;
-        return true;
-      }
       if (parse_greater_greater()) {
         op = TokenKind::T_GREATER_GREATER;
         return true;
       }
-      if (parse_greater_equal()) {
-        op = TokenKind::T_GREATER_EQUAL;
-        return true;
-      }
       consumeToken();
       return true;
     }

src/parser/cxx/parser.h

@@ -84,8 +84,6 @@ class Parser final {
       -> bool;
   [[nodiscard]] auto parse_nospace() -> bool;
   [[nodiscard]] auto parse_greater_greater() -> bool;
-  [[nodiscard]] auto parse_greater_greater_equal() -> bool;
-  [[nodiscard]] auto parse_greater_equal() -> bool;
   [[nodiscard]] auto parse_header_name(SourceLocation& loc) -> bool;
   [[nodiscard]] auto parse_export_keyword(SourceLocation& loc) -> bool;
   [[nodiscard]] auto parse_import_keyword(SourceLocation& loc) -> bool;

src/parser/cxx/preprocessor.cc

@@ -1860,35 +1860,7 @@ void Preprocessor::preprocess(std::string source, std::string fileName,
         break;
     }  // switch
 
-    if (tk->kind == TokenKind::T_GREATER_EQUAL) {
-      value.tokenKindValue = tk->kind;
-
-      Token token(TokenKind::T_GREATER, tk->offset, 1, value);
-      token.setFileId(fileId);
-      token.setLeadingSpace(tk->space);
-      token.setStartOfLine(tk->bol);
-      tokens.push_back(token);
-
-      token = Token(TokenKind::T_EQUAL, tk->offset + 1, 1);
-      token.setFileId(fileId);
-      token.setLeadingSpace(false);
-      token.setStartOfLine(false);
-      tokens.push_back(token);
-    } else if (tk->kind == TokenKind::T_GREATER_GREATER) {
-      value.tokenKindValue = tk->kind;
-
-      Token token(TokenKind::T_GREATER, tk->offset, 1);
-      token.setFileId(fileId);
-      token.setLeadingSpace(tk->space);
-      token.setStartOfLine(tk->bol);
-      tokens.push_back(token);
-
-      token = Token(TokenKind::T_GREATER, tk->offset + 1, 1);
-      token.setFileId(fileId);
-      token.setLeadingSpace(false);
-      token.setStartOfLine(false);
-      tokens.push_back(token);
-    } else if (tk->kind == TokenKind::T_GREATER_GREATER_EQUAL) {
+    if (tk->kind == TokenKind::T_GREATER_GREATER) {
       value.tokenKindValue = tk->kind;
 
       Token token(TokenKind::T_GREATER, tk->offset, 1);
@@ -1902,13 +1874,6 @@ void Preprocessor::preprocess(std::string source, std::string fileName,
       token.setLeadingSpace(false);
       token.setStartOfLine(false);
       tokens.push_back(token);
-
-      token = Token(TokenKind::T_EQUAL, tk->offset + 2, 1);
-      token.setFileId(fileId);
-      token.setLeadingSpace(false);
-      token.setStartOfLine(false);
-      tokens.push_back(token);
-
     } else {
       Token token(kind, tk->offset, tk->length, value);
       token.setFileId(fileId);