chore: Parse gcc statements in expressions

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

packages/cxx-frontend/src/AST.ts

@@ -3878,6 +3878,48 @@ export class ThisExpressionAST extends ExpressionAST {
   }
 }
 
+/**
+ * NestedStatementExpressionAST node.
+ */
+export class NestedStatementExpressionAST extends ExpressionAST {
+  /**
+   * Traverse this node using the given visitor.
+   * @param visitor the visitor.
+   * @param context the context.
+   * @returns the result of the visit.
+   */
+  accept<Context, Result>(
+    visitor: ASTVisitor<Context, Result>,
+    context: Context,
+  ): Result {
+    return visitor.visitNestedStatementExpression(this, context);
+  }
+
+  /**
+   * Returns the location of the lparen token in this node
+   */
+  getLparenToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+  }
+
+  /**
+   * Returns the statement of this node
+   */
+  getStatement(): CompoundStatementAST | undefined {
+    return AST.from<CompoundStatementAST>(
+      cxx.getASTSlot(this.getHandle(), 1),
+      this.parser,
+    );
+  }
+
+  /**
+   * Returns the location of the rparen token in this node
+   */
+  getRparenToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 2), this.parser);
+  }
+}
+
 /**
  * NestedExpressionAST node.
  */
@@ -12752,6 +12794,7 @@ const AST_CONSTRUCTORS: Array<
   StringLiteralExpressionAST,
   UserDefinedStringLiteralExpressionAST,
   ThisExpressionAST,
+  NestedStatementExpressionAST,
   NestedExpressionAST,
   IdExpressionAST,
   LambdaExpressionAST,

packages/cxx-frontend/src/ASTKind.ts

@@ -85,6 +85,7 @@ export enum ASTKind {
   StringLiteralExpression,
   UserDefinedStringLiteralExpression,
   ThisExpression,
+  NestedStatementExpression,
   NestedExpression,
   IdExpression,
   LambdaExpression,

packages/cxx-frontend/src/ASTVisitor.ts

@@ -721,6 +721,18 @@ export abstract class ASTVisitor<Context, Result> {
     context: Context,
   ): Result;
 
+  /**
+   * Visit NestedStatementExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitNestedStatementExpression(
+    node: ast.NestedStatementExpressionAST,
+    context: Context,
+  ): Result;
+
   /**
    * Visit NestedExpression node.
    *

packages/cxx-frontend/src/RecursiveASTVisitor.ts

@@ -830,6 +830,19 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
    */
   visitThisExpression(node: ast.ThisExpressionAST, context: Context): void {}
 
+  /**
+   * Visit a NestedStatementExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitNestedStatementExpression(
+    node: ast.NestedStatementExpressionAST,
+    context: Context,
+  ): void {
+    this.accept(node.getStatement(), context);
+  }
+
   /**
    * Visit a NestedExpression node.
    *

src/frontend/cxx/ast_printer.cc

@@ -783,6 +783,11 @@ void ASTPrinter::visit(ThisExpressionAST* ast) {
   out_ << std::format("{}\n", "this-expression");
 }
 
+void ASTPrinter::visit(NestedStatementExpressionAST* ast) {
+  out_ << std::format("{}\n", "nested-statement-expression");
+  accept(ast->statement, "statement");
+}
+
 void ASTPrinter::visit(NestedExpressionAST* ast) {
   out_ << std::format("{}\n", "nested-expression");
   accept(ast->expression, "expression");

src/frontend/cxx/ast_printer.h

@@ -104,6 +104,7 @@ class ASTPrinter : ASTVisitor {
   void visit(StringLiteralExpressionAST* ast) override;
   void visit(UserDefinedStringLiteralExpressionAST* ast) override;
   void visit(ThisExpressionAST* ast) override;
+  void visit(NestedStatementExpressionAST* ast) override;
   void visit(NestedExpressionAST* ast) override;
   void visit(IdExpressionAST* ast) override;
   void visit(LambdaExpressionAST* ast) override;

src/parser/cxx/ast.cc

@@ -958,6 +958,20 @@ auto ThisExpressionAST::lastSourceLocation() -> SourceLocation {
   return {};
 }
 
+auto NestedStatementExpressionAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(lparenLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(statement)) return loc;
+  if (auto loc = cxx::firstSourceLocation(rparenLoc)) return loc;
+  return {};
+}
+
+auto NestedStatementExpressionAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(rparenLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(statement)) return loc;
+  if (auto loc = cxx::lastSourceLocation(lparenLoc)) return loc;
+  return {};
+}
+
 auto NestedExpressionAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(lparenLoc)) return loc;
   if (auto loc = cxx::firstSourceLocation(expression)) return loc;

src/parser/cxx/ast.fbs

@@ -130,6 +130,7 @@ union Expression {
   StringLiteralExpression,
   UserDefinedStringLiteralExpression,
   ThisExpression,
+  NestedStatementExpression,
   NestedExpression,
   IdExpression,
   LambdaExpression,
@@ -876,6 +877,12 @@ table ThisExpression /* ExpressionAST */ {
   this_loc: uint32;
 }
 
+table NestedStatementExpression /* ExpressionAST */ {
+  statement: CompoundStatement;
+  lparen_loc: uint32;
+  rparen_loc: uint32;
+}
+
 table NestedExpression /* ExpressionAST */ {
   expression: Expression;
   lparen_loc: uint32;

src/parser/cxx/ast.h

@@ -1281,6 +1281,22 @@ class ThisExpressionAST final : public ExpressionAST {
   auto lastSourceLocation() -> SourceLocation override;
 };
 
+class NestedStatementExpressionAST final : public ExpressionAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::NestedStatementExpression;
+
+  NestedStatementExpressionAST() : ExpressionAST(Kind) {}
+
+  SourceLocation lparenLoc;
+  CompoundStatementAST* statement = nullptr;
+  SourceLocation rparenLoc;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
 class NestedExpressionAST final : public ExpressionAST {
  public:
   static constexpr ASTKind Kind = ASTKind::NestedExpression;
@@ -4363,6 +4379,9 @@ auto visit(Visitor&& visitor, ExpressionAST* ast) {
     case ThisExpressionAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<ThisExpressionAST*>(ast));
+    case NestedStatementExpressionAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<NestedStatementExpressionAST*>(ast));
     case NestedExpressionAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<NestedExpressionAST*>(ast));
@@ -4527,6 +4546,7 @@ auto visit(Visitor&& visitor, ExpressionAST* ast) {
     case StringLiteralExpressionAST::Kind:
     case UserDefinedStringLiteralExpressionAST::Kind:
     case ThisExpressionAST::Kind:
+    case NestedStatementExpressionAST::Kind:
     case NestedExpressionAST::Kind:
     case IdExpressionAST::Kind:
     case LambdaExpressionAST::Kind:

src/parser/cxx/ast_fwd.h

@@ -143,6 +143,7 @@ class NullptrLiteralExpressionAST;
 class StringLiteralExpressionAST;
 class UserDefinedStringLiteralExpressionAST;
 class ThisExpressionAST;
+class NestedStatementExpressionAST;
 class NestedExpressionAST;
 class IdExpressionAST;
 class LambdaExpressionAST;