Parse C _Atomic qualifier and type qualifiers in array declarators

packages/cxx-frontend/src/AST.ts

@@ -9698,6 +9698,31 @@ export class VolatileQualifierAST extends SpecifierAST {
   }
 }
 
+/**
+ * AtomicQualifierAST node.
+ */
+export class AtomicQualifierAST extends SpecifierAST {
+  /**
+   * 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.visitAtomicQualifier(this, context);
+  }
+
+  /**
+   * Returns the location of the atomic token in this node
+   */
+  getAtomicToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+  }
+}
+
 /**
  * RestrictQualifierAST node.
  */
@@ -10728,12 +10753,38 @@ export class ArrayDeclaratorChunkAST extends DeclaratorChunkAST {
     return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
   }
 
+  /**
+   * Returns the typeQualifierList of this node
+   */
+  getTypeQualifierList(): Iterable<SpecifierAST | undefined> {
+    let it = cxx.getASTSlot(this.getHandle(), 0);
+    let value: SpecifierAST | undefined;
+    let done = false;
+    const p = this.parser;
+    function advance() {
+      done = it === 0;
+      if (done) return;
+      const ast = cxx.getListValue(it);
+      value = AST.from<SpecifierAST>(ast, p);
+      it = cxx.getListNext(it);
+    }
+    function next() {
+      advance();
+      return { done, value };
+    }
+    return {
+      [Symbol.iterator]() {
+        return { next };
+      },
+    };
+  }
+
   /**
    * Returns the expression of this node
    */
   getExpression(): ExpressionAST | undefined {
     return AST.from<ExpressionAST>(
-      cxx.getASTSlot(this.getHandle(), 1),
+      cxx.getASTSlot(this.getHandle(), 2),
       this.parser,
     );
   }
@@ -10742,7 +10793,7 @@ export class ArrayDeclaratorChunkAST extends DeclaratorChunkAST {
    * Returns the location of the rbracket token in this node
    */
   getRbracketToken(): Token | undefined {
-    return Token.from(cxx.getASTSlot(this.getHandle(), 2), this.parser);
+    return Token.from(cxx.getASTSlot(this.getHandle(), 3), this.parser);
   }
 
   /**
@@ -13144,6 +13195,7 @@ const AST_CONSTRUCTORS: Array<
   PlaceholderTypeSpecifierAST,
   ConstQualifierAST,
   VolatileQualifierAST,
+  AtomicQualifierAST,
   RestrictQualifierAST,
   EnumSpecifierAST,
   ClassSpecifierAST,

packages/cxx-frontend/src/ASTKind.ts

@@ -208,6 +208,7 @@ export enum ASTKind {
   PlaceholderTypeSpecifier,
   ConstQualifier,
   VolatileQualifier,
+  AtomicQualifier,
   RestrictQualifier,
   EnumSpecifier,
   ClassSpecifier,

packages/cxx-frontend/src/ASTSlot.ts

@@ -234,21 +234,22 @@ export enum ASTSlot {
   typeId = 212,
   typeIdList = 213,
   typeLoc = 214,
-  typeSpecifier = 215,
-  typeSpecifierList = 216,
-  typeTraitLoc = 217,
-  typedefLoc = 218,
-  typeidLoc = 219,
-  typenameLoc = 220,
-  underlyingTypeLoc = 221,
-  unqualifiedId = 222,
-  usingDeclaratorList = 223,
-  usingLoc = 224,
-  vaArgLoc = 225,
-  virtualLoc = 226,
-  virtualOrAccessLoc = 227,
-  voidLoc = 228,
-  volatileLoc = 229,
-  whileLoc = 230,
-  yieldLoc = 231,
+  typeQualifierList = 215,
+  typeSpecifier = 216,
+  typeSpecifierList = 217,
+  typeTraitLoc = 218,
+  typedefLoc = 219,
+  typeidLoc = 220,
+  typenameLoc = 221,
+  underlyingTypeLoc = 222,
+  unqualifiedId = 223,
+  usingDeclaratorList = 224,
+  usingLoc = 225,
+  vaArgLoc = 226,
+  virtualLoc = 227,
+  virtualOrAccessLoc = 228,
+  voidLoc = 229,
+  volatileLoc = 230,
+  whileLoc = 231,
+  yieldLoc = 232,
 }

packages/cxx-frontend/src/ASTVisitor.ts

@@ -2077,6 +2077,18 @@ export abstract class ASTVisitor<Context, Result> {
     context: Context,
   ): Result;
 
+  /**
+   * Visit AtomicQualifier node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitAtomicQualifier(
+    node: ast.AtomicQualifierAST,
+    context: Context,
+  ): Result;
+
   /**
    * Visit RestrictQualifier node.
    *

packages/cxx-frontend/src/RecursiveASTVisitor.ts

@@ -2234,6 +2234,14 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     context: Context,
   ): void {}
 
+  /**
+   * Visit a AtomicQualifier node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitAtomicQualifier(node: ast.AtomicQualifierAST, context: Context): void {}
+
   /**
    * Visit a RestrictQualifier node.
    *
@@ -2440,6 +2448,9 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     node: ast.ArrayDeclaratorChunkAST,
     context: Context,
   ): void {
+    for (const element of node.getTypeQualifierList()) {
+      this.accept(element, context);
+    }
     this.accept(node.getExpression(), context);
     for (const element of node.getAttributeList()) {
       this.accept(element, context);

src/mlir/cxx/mlir/codegen.cc

@@ -397,6 +397,8 @@ struct Codegen::SpecifierVisitor {
 
   [[nodiscard]] auto operator()(RestrictQualifierAST* ast) -> SpecifierResult;
 
+  [[nodiscard]] auto operator()(AtomicQualifierAST* ast) -> SpecifierResult;
+
   [[nodiscard]] auto operator()(EnumSpecifierAST* ast) -> SpecifierResult;
 
   [[nodiscard]] auto operator()(ClassSpecifierAST* ast) -> SpecifierResult;
@@ -2417,6 +2419,11 @@ auto Codegen::SpecifierVisitor::operator()(RestrictQualifierAST* ast)
   return {};
 }
 
+auto Codegen::SpecifierVisitor::operator()(AtomicQualifierAST* ast)
+    -> SpecifierResult {
+  return {};
+}
+
 auto Codegen::SpecifierVisitor::operator()(EnumSpecifierAST* ast)
     -> SpecifierResult {
   for (auto node : ListView{ast->attributeList}) {

src/parser/cxx/ast.cc

@@ -2616,6 +2616,16 @@ auto VolatileQualifierAST::lastSourceLocation() -> SourceLocation {
   return {};
 }
 
+auto AtomicQualifierAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(atomicLoc)) return loc;
+  return {};
+}
+
+auto AtomicQualifierAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(atomicLoc)) return loc;
+  return {};
+}
+
 auto RestrictQualifierAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(restrictLoc)) return loc;
   return {};
@@ -2838,6 +2848,7 @@ auto FunctionDeclaratorChunkAST::lastSourceLocation() -> SourceLocation {
 
 auto ArrayDeclaratorChunkAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(lbracketLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(typeQualifierList)) return loc;
   if (auto loc = cxx::firstSourceLocation(expression)) return loc;
   if (auto loc = cxx::firstSourceLocation(rbracketLoc)) return loc;
   if (auto loc = cxx::firstSourceLocation(attributeList)) return loc;
@@ -2848,6 +2859,7 @@ auto ArrayDeclaratorChunkAST::lastSourceLocation() -> SourceLocation {
   if (auto loc = cxx::lastSourceLocation(attributeList)) return loc;
   if (auto loc = cxx::lastSourceLocation(rbracketLoc)) return loc;
   if (auto loc = cxx::lastSourceLocation(expression)) return loc;
+  if (auto loc = cxx::lastSourceLocation(typeQualifierList)) return loc;
   if (auto loc = cxx::lastSourceLocation(lbracketLoc)) return loc;
   return {};
 }
@@ -3670,6 +3682,7 @@ std::string_view kASTKindNames[] = {
     "placeholder-type-specifier",
     "const-qualifier",
     "volatile-qualifier",
+    "atomic-qualifier",
     "restrict-qualifier",
     "enum-specifier",
     "class-specifier",

src/parser/cxx/ast.fbs

@@ -268,6 +268,7 @@ union Specifier {
   PlaceholderTypeSpecifier,
   ConstQualifier,
   VolatileQualifier,
+  AtomicQualifier,
   RestrictQualifier,
   EnumSpecifier,
   ClassSpecifier,
@@ -817,6 +818,7 @@ table FunctionDeclaratorChunk /* DeclaratorChunkAST */ {
 }
 
 table ArrayDeclaratorChunk /* DeclaratorChunkAST */ {
+  type_qualifier_list: [Specifier];
   expression: Expression;
   attribute_list: [AttributeSpecifier];
   lbracket_loc: uint32;
@@ -1587,6 +1589,10 @@ table VolatileQualifier /* SpecifierAST */ {
   volatile_loc: uint32;
 }
 
+table AtomicQualifier /* SpecifierAST */ {
+  atomic_loc: uint32;
+}
+
 table RestrictQualifier /* SpecifierAST */ {
   restrict_loc: uint32;
 }

src/parser/cxx/ast.h

@@ -3232,6 +3232,20 @@ class VolatileQualifierAST final : public SpecifierAST {
   auto lastSourceLocation() -> SourceLocation override;
 };
 
+class AtomicQualifierAST final : public SpecifierAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::AtomicQualifier;
+
+  AtomicQualifierAST() : SpecifierAST(Kind) {}
+
+  SourceLocation atomicLoc;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
 class RestrictQualifierAST final : public SpecifierAST {
  public:
   static constexpr ASTKind Kind = ASTKind::RestrictQualifier;
@@ -3475,6 +3489,7 @@ class ArrayDeclaratorChunkAST final : public DeclaratorChunkAST {
   ArrayDeclaratorChunkAST() : DeclaratorChunkAST(Kind) {}
 
   SourceLocation lbracketLoc;
+  List<SpecifierAST*>* typeQualifierList = nullptr;
   ExpressionAST* expression = nullptr;
   SourceLocation rbracketLoc;
   List<AttributeSpecifierAST*>* attributeList = nullptr;
@@ -4895,6 +4910,9 @@ auto visit(Visitor&& visitor, SpecifierAST* ast) {
     case VolatileQualifierAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<VolatileQualifierAST*>(ast));
+    case AtomicQualifierAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<AtomicQualifierAST*>(ast));
     case RestrictQualifierAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<RestrictQualifierAST*>(ast));
@@ -4952,6 +4970,7 @@ template <>
     case PlaceholderTypeSpecifierAST::Kind:
     case ConstQualifierAST::Kind:
     case VolatileQualifierAST::Kind:
+    case AtomicQualifierAST::Kind:
     case RestrictQualifierAST::Kind:
     case EnumSpecifierAST::Kind:
     case ClassSpecifierAST::Kind:

src/parser/cxx/ast_fwd.h

@@ -267,6 +267,7 @@ class DecltypeSpecifierAST;
 class PlaceholderTypeSpecifierAST;
 class ConstQualifierAST;
 class VolatileQualifierAST;
+class AtomicQualifierAST;
 class RestrictQualifierAST;
 class EnumSpecifierAST;
 class ClassSpecifierAST;

src/parser/cxx/ast_interpreter.cc

@@ -522,6 +522,8 @@ struct ASTInterpreter::SpecifierVisitor {
 
   [[nodiscard]] auto operator()(RestrictQualifierAST* ast) -> SpecifierResult;
 
+  [[nodiscard]] auto operator()(AtomicQualifierAST* ast) -> SpecifierResult;
+
   [[nodiscard]] auto operator()(EnumSpecifierAST* ast) -> SpecifierResult;
 
   [[nodiscard]] auto operator()(ClassSpecifierAST* ast) -> SpecifierResult;
@@ -2727,6 +2729,11 @@ auto ASTInterpreter::SpecifierVisitor::operator()(RestrictQualifierAST* ast)
   return {};
 }
 
+auto ASTInterpreter::SpecifierVisitor::operator()(AtomicQualifierAST* ast)
+    -> SpecifierResult {
+  return {};
+}
+
 auto ASTInterpreter::SpecifierVisitor::operator()(EnumSpecifierAST* ast)
     -> SpecifierResult {
   for (auto node : ListView{ast->attributeList}) {

src/parser/cxx/ast_kind.h

@@ -213,6 +213,7 @@ enum class ASTKind {
   PlaceholderTypeSpecifier,
   ConstQualifier,
   VolatileQualifier,
+  AtomicQualifier,
   RestrictQualifier,
   EnumSpecifier,
   ClassSpecifier,

src/parser/cxx/ast_pretty_printer.cc

@@ -422,6 +422,8 @@ struct ASTPrettyPrinter::SpecifierVisitor {
 
   void operator()(VolatileQualifierAST* ast);
 
+  void operator()(AtomicQualifierAST* ast);
+
   void operator()(RestrictQualifierAST* ast);
 
   void operator()(EnumSpecifierAST* ast);
@@ -3492,6 +3494,12 @@ void ASTPrettyPrinter::SpecifierVisitor::operator()(VolatileQualifierAST* ast) {
   }
 }
 
+void ASTPrettyPrinter::SpecifierVisitor::operator()(AtomicQualifierAST* ast) {
+  if (ast->atomicLoc) {
+    accept.writeToken(ast->atomicLoc);
+  }
+}
+
 void ASTPrettyPrinter::SpecifierVisitor::operator()(RestrictQualifierAST* ast) {
   if (ast->restrictLoc) {
     accept.writeToken(ast->restrictLoc);
@@ -3735,6 +3743,11 @@ void ASTPrettyPrinter::DeclaratorChunkVisitor::operator()(
     accept.writeToken(ast->lbracketLoc);
     nospace();
   }
+
+  for (auto it = ast->typeQualifierList; it; it = it->next) {
+    accept(it->value);
+  }
+
   accept(ast->expression);
   if (ast->rbracketLoc) {
     nospace();