Parse C object literal expressions

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

Author: robertoraggi

packages/cxx-frontend/src/AST.ts

@@ -3854,6 +3854,58 @@ export class UserDefinedStringLiteralExpressionAST extends ExpressionAST {
   }
 }
 
+/**
+ * ObjectLiteralExpressionAST node.
+ */
+export class ObjectLiteralExpressionAST 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.visitObjectLiteralExpression(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 typeId of this node
+   */
+  getTypeId(): TypeIdAST | undefined {
+    return AST.from<TypeIdAST>(
+      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);
+  }
+
+  /**
+   * Returns the bracedInitList of this node
+   */
+  getBracedInitList(): BracedInitListAST | undefined {
+    return AST.from<BracedInitListAST>(
+      cxx.getASTSlot(this.getHandle(), 3),
+      this.parser,
+    );
+  }
+}
+
 /**
  * ThisExpressionAST node.
  */
@@ -12976,6 +13028,7 @@ const AST_CONSTRUCTORS: Array<
   NullptrLiteralExpressionAST,
   StringLiteralExpressionAST,
   UserDefinedStringLiteralExpressionAST,
+  ObjectLiteralExpressionAST,
   ThisExpressionAST,
   NestedStatementExpressionAST,
   NestedExpressionAST,

packages/cxx-frontend/src/ASTKind.ts

@@ -84,6 +84,7 @@ export enum ASTKind {
   NullptrLiteralExpression,
   StringLiteralExpression,
   UserDefinedStringLiteralExpression,
+  ObjectLiteralExpression,
   ThisExpression,
   NestedStatementExpression,
   NestedExpression,

packages/cxx-frontend/src/ASTVisitor.ts

@@ -709,6 +709,18 @@ export abstract class ASTVisitor<Context, Result> {
     context: Context,
   ): Result;
 
+  /**
+   * Visit ObjectLiteralExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitObjectLiteralExpression(
+    node: ast.ObjectLiteralExpressionAST,
+    context: Context,
+  ): Result;
+
   /**
    * Visit ThisExpression node.
    *

packages/cxx-frontend/src/RecursiveASTVisitor.ts

@@ -822,6 +822,20 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     context: Context,
   ): void {}
 
+  /**
+   * Visit a ObjectLiteralExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitObjectLiteralExpression(
+    node: ast.ObjectLiteralExpressionAST,
+    context: Context,
+  ): void {
+    this.accept(node.getTypeId(), context);
+    this.accept(node.getBracedInitList(), context);
+  }
+
   /**
    * Visit a ThisExpression node.
    *

src/mlir/cxx/mlir/codegen.cc

@@ -174,6 +174,9 @@ struct Codegen::ExpressionVisitor {
   [[nodiscard]] auto operator()(UserDefinedStringLiteralExpressionAST* ast)
       -> ExpressionResult;
 
+  [[nodiscard]] auto operator()(ObjectLiteralExpressionAST* ast)
+      -> ExpressionResult;
+
   [[nodiscard]] auto operator()(ThisExpressionAST* ast) -> ExpressionResult;
 
   [[nodiscard]] auto operator()(NestedStatementExpressionAST* ast)
@@ -1619,6 +1622,13 @@ auto Codegen::ExpressionVisitor::operator()(
   return {op};
 }
 
+auto Codegen::ExpressionVisitor::operator()(ObjectLiteralExpressionAST* ast)
+    -> ExpressionResult {
+  auto op = gen.emitTodoExpr(ast->firstSourceLocation(),
+                             "ObjectLiteralExpressionAST");
+  return {op};
+}
+
 auto Codegen::ExpressionVisitor::operator()(ThisExpressionAST* ast)
     -> ExpressionResult {
   auto op = gen.emitTodoExpr(ast->firstSourceLocation(), "ThisExpressionAST");

src/parser/cxx/ast.cc

@@ -948,6 +948,22 @@ auto UserDefinedStringLiteralExpressionAST::lastSourceLocation()
   return {};
 }
 
+auto ObjectLiteralExpressionAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(lparenLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(typeId)) return loc;
+  if (auto loc = cxx::firstSourceLocation(rparenLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(bracedInitList)) return loc;
+  return {};
+}
+
+auto ObjectLiteralExpressionAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(bracedInitList)) return loc;
+  if (auto loc = cxx::lastSourceLocation(rparenLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(typeId)) return loc;
+  if (auto loc = cxx::lastSourceLocation(lparenLoc)) return loc;
+  return {};
+}
+
 auto ThisExpressionAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(thisLoc)) return loc;
   return {};
@@ -3530,6 +3546,7 @@ std::string_view kASTKindNames[] = {
     "nullptr-literal-expression",
     "string-literal-expression",
     "user-defined-string-literal-expression",
+    "object-literal-expression",
     "this-expression",
     "nested-statement-expression",
     "nested-expression",

src/parser/cxx/ast.fbs

@@ -134,6 +134,7 @@ union Expression {
   NullptrLiteralExpression,
   StringLiteralExpression,
   UserDefinedStringLiteralExpression,
+  ObjectLiteralExpression,
   ThisExpression,
   NestedStatementExpression,
   NestedExpression,
@@ -895,6 +896,13 @@ table UserDefinedStringLiteralExpression /* ExpressionAST */ {
   literal_loc: uint32;
 }
 
+table ObjectLiteralExpression /* ExpressionAST */ {
+  type_id: TypeId;
+  braced_init_list: BracedInitList;
+  lparen_loc: uint32;
+  rparen_loc: uint32;
+}
+
 table ThisExpression /* ExpressionAST */ {
   this_loc: uint32;
 }

src/parser/cxx/ast.h

@@ -1293,6 +1293,23 @@ class UserDefinedStringLiteralExpressionAST final : public ExpressionAST {
   auto lastSourceLocation() -> SourceLocation override;
 };
 
+class ObjectLiteralExpressionAST final : public ExpressionAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::ObjectLiteralExpression;
+
+  ObjectLiteralExpressionAST() : ExpressionAST(Kind) {}
+
+  SourceLocation lparenLoc;
+  TypeIdAST* typeId = nullptr;
+  SourceLocation rparenLoc;
+  BracedInitListAST* bracedInitList = nullptr;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
 class ThisExpressionAST final : public ExpressionAST {
  public:
   static constexpr ASTKind Kind = ASTKind::ThisExpression;
@@ -4484,6 +4501,9 @@ auto visit(Visitor&& visitor, ExpressionAST* ast) {
       return std::invoke(
           std::forward<Visitor>(visitor),
           static_cast<UserDefinedStringLiteralExpressionAST*>(ast));
+    case ObjectLiteralExpressionAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<ObjectLiteralExpressionAST*>(ast));
     case ThisExpressionAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<ThisExpressionAST*>(ast));
@@ -4654,6 +4674,7 @@ template <>
     case NullptrLiteralExpressionAST::Kind:
     case StringLiteralExpressionAST::Kind:
     case UserDefinedStringLiteralExpressionAST::Kind:
+    case ObjectLiteralExpressionAST::Kind:
     case ThisExpressionAST::Kind:
     case NestedStatementExpressionAST::Kind:
     case NestedExpressionAST::Kind:

src/parser/cxx/ast_fwd.h

@@ -143,6 +143,7 @@ class FloatLiteralExpressionAST;
 class NullptrLiteralExpressionAST;
 class StringLiteralExpressionAST;
 class UserDefinedStringLiteralExpressionAST;
+class ObjectLiteralExpressionAST;
 class ThisExpressionAST;
 class NestedStatementExpressionAST;
 class NestedExpressionAST;

src/parser/cxx/ast_interpreter.cc

@@ -299,6 +299,9 @@ struct ASTInterpreter::ExpressionVisitor {
   [[nodiscard]] auto operator()(UserDefinedStringLiteralExpressionAST* ast)
       -> ExpressionResult;
 
+  [[nodiscard]] auto operator()(ObjectLiteralExpressionAST* ast)
+      -> ExpressionResult;
+
   [[nodiscard]] auto operator()(ThisExpressionAST* ast) -> ExpressionResult;
 
   [[nodiscard]] auto operator()(NestedStatementExpressionAST* ast)
@@ -1623,6 +1626,11 @@ auto ASTInterpreter::ExpressionVisitor::operator()(
   return ConstValue(ast->literal);
 }
 
+auto ASTInterpreter::ExpressionVisitor::operator()(
+    ObjectLiteralExpressionAST* ast) -> ExpressionResult {
+  return std::nullopt;
+}
+
 auto ASTInterpreter::ExpressionVisitor::operator()(ThisExpressionAST* ast)
     -> ExpressionResult {
   return std::nullopt;