Exclude fold expressions and for range loops in C mode

Author: robertoraggi

packages/cxx-gen-ast/src/tokens.ts

@@ -365,6 +365,8 @@ export const C_TOKEN_ALIASES = {
   _Bool: "BOOL",
   _Static_assert: "STATIC_ASSERT",
   _Thread_local: "THREAD_LOCAL",
+  __typeof__: "typeof",
+  __typeof: "typeof",
 };
 
 export const C_AND_CXX_KEYWORDS = Array.from(

src/parser/cxx/parser.cc

@@ -246,6 +246,14 @@ auto Parser::prec(TokenKind tk) -> Parser::Prec {
   }  // switch
 }
 
+auto Parser::is_c() const -> bool {
+  return unit->language() == LanguageKind::kC;
+}
+
+auto Parser::is_cxx() const -> bool {
+  return unit->language() == LanguageKind::kCXX;
+}
+
 auto Parser::LA(int n) const -> const Token& {
   return unit->tokenAt(SourceLocation(cursor_ + n));
 }
@@ -1462,6 +1470,8 @@ auto Parser::parse_nested_expession(ExpressionAST*& yyast,
 
 auto Parser::parse_fold_expression(ExpressionAST*& yyast,
                                    const ExprContext& ctx) -> bool {
+  if (!is_cxx()) return false;
+
   if (!lookat(TokenKind::T_LPAREN)) return false;
 
   if (parse_left_fold_expression(yyast, ctx)) return true;
@@ -3513,6 +3523,8 @@ auto Parser::parse_for_statement(StatementAST*& yyast) -> bool {
   SourceLocation colonLoc;
 
   auto lookat_for_range_declaration = [&] {
+    if (!is_cxx()) return false;
+
     LookaheadParser lookahead{this};
 
     if (!parse_for_range_declaration(rangeDeclaration)) return false;
@@ -6021,9 +6033,7 @@ auto Parser::parse_initializer_list(List<ExpressionAST*>*& yyast,
 auto Parser::lookat_designator() -> bool {
   if (lookat(TokenKind::T_DOT)) return true;
 
-  if (unit->language() == LanguageKind::kCXX) return false;
-
-  if (lookat(TokenKind::T_LBRACKET)) return true;
+  if (is_c() && lookat(TokenKind::T_LBRACKET)) return true;
 
   return false;
 }
@@ -6072,7 +6082,7 @@ auto Parser::parse_designated_initializer_clause(
   *it = make_list_node(pool_, designator);
   it = &(*it)->next;
 
-  if (unit->language() == LanguageKind::kC) {
+  if (is_c()) {
     while (lookat_designator()) {
       DesignatorAST* designator = nullptr;
       parse_designator(designator);

src/parser/cxx/parser.h

@@ -739,6 +739,9 @@ class Parser final {
   [[nodiscard]] auto parse_identifier_list(List<NameIdAST*>*& yyast) -> bool;
 
  private:
+ [[nodiscard]] auto is_c() const -> bool;
+ [[nodiscard]] auto is_cxx() const -> bool;
+
   [[nodiscard]] auto lookat(auto... tokens) {
     return lookatHelper(0, tokens...);
   }

src/parser/cxx/private/c_keywords-priv.h

@@ -620,6 +620,16 @@ static inline auto classifyC8(const char* s) -> cxx::TokenKind {
               }
             }
           }
+        } else if (s[3] == 'y') {
+          if (s[4] == 'p') {
+            if (s[5] == 'e') {
+              if (s[6] == 'o') {
+                if (s[7] == 'f') {
+                  return cxx::TokenKind::T___TYPEOF;
+                }
+              }
+            }
+          }
         }
       }
     } else if (s[1] == 'A') {
@@ -777,6 +787,22 @@ static inline auto classifyC10(const char* s) -> cxx::TokenKind {
             }
           }
         }
+      } else if (s[2] == 't') {
+        if (s[3] == 'y') {
+          if (s[4] == 'p') {
+            if (s[5] == 'e') {
+              if (s[6] == 'o') {
+                if (s[7] == 'f') {
+                  if (s[8] == '_') {
+                    if (s[9] == '_') {
+                      return cxx::TokenKind::T___TYPEOF__;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
       }
     }
   }

src/parser/cxx/token_fwd.h

@@ -276,6 +276,8 @@ class Token;
   V(_BOOL, BOOL)                   \
   V(_STATIC_ASSERT, STATIC_ASSERT) \
   V(_THREAD_LOCAL, THREAD_LOCAL)   \
+  V(__TYPEOF__, DECLTYPE)          \
+  V(__TYPEOF, DECLTYPE)            \
   V(AND_EQ, AMP_EQUAL)             \
   V(AND, AMP_AMP)                  \
   V(BITAND, AMP)                   \
@@ -293,8 +295,6 @@ class Token;
   V(__DECLTYPE__, DECLTYPE)        \
   V(__DECLTYPE, DECLTYPE)          \
   V(__RESTRICT, __RESTRICT__)      \
-  V(__TYPEOF__, DECLTYPE)          \
-  V(__TYPEOF, DECLTYPE)            \
   V(__VOLATILE__, VOLATILE)        \
   V(__VOLATILE, VOLATILE)