diff --git a/packages/cxx-frontend/src/AST.ts b/packages/cxx-frontend/src/AST.ts
index 0fd08eb6..c44b33d1 100644
--- a/packages/cxx-frontend/src/AST.ts
+++ b/packages/cxx-frontend/src/AST.ts
@@ -158,6 +158,7 @@ export abstract class ExceptionDeclarationAST extends AST {}
 export abstract class ExceptionSpecifierAST extends AST {}
 export abstract class ExpressionAST extends AST {}
 export abstract class FunctionBodyAST extends AST {}
+export abstract class GenericAssociationAST extends AST {}
 export abstract class LambdaCaptureAST extends AST {}
 export abstract class MemInitializerAST extends AST {}
 export abstract class NestedNameSpecifierAST extends AST {}
@@ -3932,6 +3933,88 @@ export class ThisExpressionAST extends ExpressionAST {
   }
 }
 
+/**
+ * GenericSelectionExpressionAST node.
+ */
+export class GenericSelectionExpressionAST 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.visitGenericSelectionExpression(this, context);
+  }
+
+  /**
+   * Returns the location of the generic token in this node
+   */
+  getGenericToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+  }
+
+  /**
+   * Returns the location of the lparen token in this node
+   */
+  getLparenToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+  }
+
+  /**
+   * Returns the expression of this node
+   */
+  getExpression(): ExpressionAST | undefined {
+    return AST.from<ExpressionAST>(
+      cxx.getASTSlot(this.getHandle(), 2),
+      this.parser,
+    );
+  }
+
+  /**
+   * Returns the location of the comma token in this node
+   */
+  getCommaToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+  }
+
+  /**
+   * Returns the genericAssociationList of this node
+   */
+  getGenericAssociationList(): Iterable<GenericAssociationAST | undefined> {
+    let it = cxx.getASTSlot(this.getHandle(), 0);
+    let value: GenericAssociationAST | undefined;
+    let done = false;
+    const p = this.parser;
+    function advance() {
+      done = it === 0;
+      if (done) return;
+      const ast = cxx.getListValue(it);
+      value = AST.from<GenericAssociationAST>(ast, p);
+      it = cxx.getListNext(it);
+    }
+    function next() {
+      advance();
+      return { done, value };
+    }
+    return {
+      [Symbol.iterator]() {
+        return { next };
+      },
+    };
+  }
+
+  /**
+   * Returns the location of the rparen token in this node
+   */
+  getRparenToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 5), this.parser);
+  }
+}
+
 /**
  * NestedStatementExpressionAST node.
  */
@@ -6814,6 +6897,93 @@ export class ParenInitializerAST extends ExpressionAST {
   }
 }
 
+/**
+ * DefaultGenericAssociationAST node.
+ */
+export class DefaultGenericAssociationAST extends GenericAssociationAST {
+  /**
+   * 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.visitDefaultGenericAssociation(this, context);
+  }
+
+  /**
+   * Returns the location of the default token in this node
+   */
+  getDefaultToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+  }
+
+  /**
+   * Returns the location of the colon token in this node
+   */
+  getColonToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+  }
+
+  /**
+   * Returns the expression of this node
+   */
+  getExpression(): ExpressionAST | undefined {
+    return AST.from<ExpressionAST>(
+      cxx.getASTSlot(this.getHandle(), 2),
+      this.parser,
+    );
+  }
+}
+
+/**
+ * TypeGenericAssociationAST node.
+ */
+export class TypeGenericAssociationAST extends GenericAssociationAST {
+  /**
+   * 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.visitTypeGenericAssociation(this, context);
+  }
+
+  /**
+   * Returns the typeId of this node
+   */
+  getTypeId(): TypeIdAST | undefined {
+    return AST.from<TypeIdAST>(
+      cxx.getASTSlot(this.getHandle(), 0),
+      this.parser,
+    );
+  }
+
+  /**
+   * Returns the location of the colon token in this node
+   */
+  getColonToken(): Token | undefined {
+    return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+  }
+
+  /**
+   * Returns the expression of this node
+   */
+  getExpression(): ExpressionAST | undefined {
+    return AST.from<ExpressionAST>(
+      cxx.getASTSlot(this.getHandle(), 2),
+      this.parser,
+    );
+  }
+}
+
 /**
  * DotDesignatorAST node.
  */
@@ -13082,6 +13252,7 @@ const AST_CONSTRUCTORS: Array<
   UserDefinedStringLiteralExpressionAST,
   ObjectLiteralExpressionAST,
   ThisExpressionAST,
+  GenericSelectionExpressionAST,
   NestedStatementExpressionAST,
   NestedExpressionAST,
   IdExpressionAST,
@@ -13132,6 +13303,8 @@ const AST_CONSTRUCTORS: Array<
   EqualInitializerAST,
   BracedInitListAST,
   ParenInitializerAST,
+  DefaultGenericAssociationAST,
+  TypeGenericAssociationAST,
   DotDesignatorAST,
   SubscriptDesignatorAST,
   SplicerAST,
diff --git a/packages/cxx-frontend/src/ASTKind.ts b/packages/cxx-frontend/src/ASTKind.ts
index 1deae510..8dabf8b0 100644
--- a/packages/cxx-frontend/src/ASTKind.ts
+++ b/packages/cxx-frontend/src/ASTKind.ts
@@ -87,6 +87,7 @@ export enum ASTKind {
   UserDefinedStringLiteralExpression,
   ObjectLiteralExpression,
   ThisExpression,
+  GenericSelectionExpression,
   NestedStatementExpression,
   NestedExpression,
   IdExpression,
@@ -138,6 +139,10 @@ export enum ASTKind {
   BracedInitList,
   ParenInitializer,
 
+  // GenericAssociationAST
+  DefaultGenericAssociation,
+  TypeGenericAssociation,
+
   // DesignatorAST
   DotDesignator,
   SubscriptDesignator,
diff --git a/packages/cxx-frontend/src/ASTSlot.ts b/packages/cxx-frontend/src/ASTSlot.ts
index 0e91c095..d50ea9c6 100644
--- a/packages/cxx-frontend/src/ASTSlot.ts
+++ b/packages/cxx-frontend/src/ASTSlot.ts
@@ -108,149 +108,151 @@ export enum ASTSlot {
   forLoc = 85,
   friendLoc = 86,
   functionBody = 87,
-  globalModuleFragment = 88,
-  gnuAtributeList = 89,
-  gnuAttributeList = 90,
-  gotoLabelList = 91,
-  gotoLoc = 92,
-  greaterLoc = 93,
-  handlerList = 94,
-  headerLoc = 95,
-  id = 96,
-  idExpression = 97,
-  identifier = 98,
-  identifierLoc = 99,
-  ifLoc = 100,
-  iffalseExpression = 101,
-  iftrueExpression = 102,
-  importLoc = 103,
-  importName = 104,
-  indexExpression = 105,
-  initDeclaratorList = 106,
-  initializer = 107,
-  inlineLoc = 108,
-  inputOperandList = 109,
-  isFinal = 110,
-  isInline = 111,
-  isNot = 112,
-  isOverride = 113,
-  isPack = 114,
-  isPure = 115,
-  isTemplateIntroduced = 116,
-  isThisIntroduced = 117,
-  isTrue = 118,
-  isVariadic = 119,
-  isVirtual = 120,
-  lambdaSpecifierList = 121,
-  lbraceLoc = 122,
-  lbracket2Loc = 123,
-  lbracketLoc = 124,
-  leftExpression = 125,
-  lessLoc = 126,
-  literal = 127,
-  literalLoc = 128,
-  literalOperatorId = 129,
-  lparen2Loc = 130,
-  lparenLoc = 131,
-  memInitializerList = 132,
-  minusGreaterLoc = 133,
-  moduleDeclaration = 134,
-  moduleLoc = 135,
-  moduleName = 136,
-  modulePartition = 137,
-  moduleQualifier = 138,
-  mutableLoc = 139,
-  namespaceLoc = 140,
-  nestedNameSpecifier = 141,
-  nestedNamespaceSpecifierList = 142,
-  newInitalizer = 143,
-  newLoc = 144,
-  newPlacement = 145,
-  noexceptLoc = 146,
-  noreturnLoc = 147,
-  offsetofLoc = 148,
-  op = 149,
-  opLoc = 150,
-  openLoc = 151,
-  operatorFunctionId = 152,
-  operatorLoc = 153,
-  otherVirtualOrAccessLoc = 154,
-  outputOperandList = 155,
-  parameterDeclarationClause = 156,
-  parameterDeclarationList = 157,
-  privateLoc = 158,
-  privateModuleFragment = 159,
-  ptrOpList = 160,
-  qualifier = 161,
-  qualifierLoc = 162,
-  questionLoc = 163,
-  rangeDeclaration = 164,
-  rangeInitializer = 165,
-  rbraceLoc = 166,
-  rbracket2Loc = 167,
-  rbracketLoc = 168,
-  refLoc = 169,
-  refOp = 170,
-  refQualifierLoc = 171,
-  registerLoc = 172,
-  requirementList = 173,
-  requiresClause = 174,
-  requiresLoc = 175,
-  restrictLoc = 176,
-  returnLoc = 177,
-  rightExpression = 178,
-  rparen2Loc = 179,
-  rparenLoc = 180,
-  scopeLoc = 181,
-  secondColonLoc = 182,
-  semicolonLoc = 183,
-  sizeExpression = 184,
-  sizeofLoc = 185,
-  specifier = 186,
-  specifierLoc = 187,
-  splicer = 188,
-  starLoc = 189,
-  statement = 190,
-  statementList = 191,
-  staticAssertLoc = 192,
-  staticLoc = 193,
-  stringLiteral = 194,
-  stringliteralLoc = 195,
-  switchLoc = 196,
-  symbolicName = 197,
-  symbolicNameLoc = 198,
-  templateArgumentList = 199,
-  templateId = 200,
-  templateLoc = 201,
-  templateParameterList = 202,
-  templateRequiresClause = 203,
-  thisLoc = 204,
-  threadLoc = 205,
-  threadLocalLoc = 206,
-  throwLoc = 207,
-  tildeLoc = 208,
-  trailingReturnType = 209,
-  tryLoc = 210,
-  typeConstraint = 211,
-  typeId = 212,
-  typeIdList = 213,
-  typeLoc = 214,
-  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,
+  genericAssociationList = 88,
+  genericLoc = 89,
+  globalModuleFragment = 90,
+  gnuAtributeList = 91,
+  gnuAttributeList = 92,
+  gotoLabelList = 93,
+  gotoLoc = 94,
+  greaterLoc = 95,
+  handlerList = 96,
+  headerLoc = 97,
+  id = 98,
+  idExpression = 99,
+  identifier = 100,
+  identifierLoc = 101,
+  ifLoc = 102,
+  iffalseExpression = 103,
+  iftrueExpression = 104,
+  importLoc = 105,
+  importName = 106,
+  indexExpression = 107,
+  initDeclaratorList = 108,
+  initializer = 109,
+  inlineLoc = 110,
+  inputOperandList = 111,
+  isFinal = 112,
+  isInline = 113,
+  isNot = 114,
+  isOverride = 115,
+  isPack = 116,
+  isPure = 117,
+  isTemplateIntroduced = 118,
+  isThisIntroduced = 119,
+  isTrue = 120,
+  isVariadic = 121,
+  isVirtual = 122,
+  lambdaSpecifierList = 123,
+  lbraceLoc = 124,
+  lbracket2Loc = 125,
+  lbracketLoc = 126,
+  leftExpression = 127,
+  lessLoc = 128,
+  literal = 129,
+  literalLoc = 130,
+  literalOperatorId = 131,
+  lparen2Loc = 132,
+  lparenLoc = 133,
+  memInitializerList = 134,
+  minusGreaterLoc = 135,
+  moduleDeclaration = 136,
+  moduleLoc = 137,
+  moduleName = 138,
+  modulePartition = 139,
+  moduleQualifier = 140,
+  mutableLoc = 141,
+  namespaceLoc = 142,
+  nestedNameSpecifier = 143,
+  nestedNamespaceSpecifierList = 144,
+  newInitalizer = 145,
+  newLoc = 146,
+  newPlacement = 147,
+  noexceptLoc = 148,
+  noreturnLoc = 149,
+  offsetofLoc = 150,
+  op = 151,
+  opLoc = 152,
+  openLoc = 153,
+  operatorFunctionId = 154,
+  operatorLoc = 155,
+  otherVirtualOrAccessLoc = 156,
+  outputOperandList = 157,
+  parameterDeclarationClause = 158,
+  parameterDeclarationList = 159,
+  privateLoc = 160,
+  privateModuleFragment = 161,
+  ptrOpList = 162,
+  qualifier = 163,
+  qualifierLoc = 164,
+  questionLoc = 165,
+  rangeDeclaration = 166,
+  rangeInitializer = 167,
+  rbraceLoc = 168,
+  rbracket2Loc = 169,
+  rbracketLoc = 170,
+  refLoc = 171,
+  refOp = 172,
+  refQualifierLoc = 173,
+  registerLoc = 174,
+  requirementList = 175,
+  requiresClause = 176,
+  requiresLoc = 177,
+  restrictLoc = 178,
+  returnLoc = 179,
+  rightExpression = 180,
+  rparen2Loc = 181,
+  rparenLoc = 182,
+  scopeLoc = 183,
+  secondColonLoc = 184,
+  semicolonLoc = 185,
+  sizeExpression = 186,
+  sizeofLoc = 187,
+  specifier = 188,
+  specifierLoc = 189,
+  splicer = 190,
+  starLoc = 191,
+  statement = 192,
+  statementList = 193,
+  staticAssertLoc = 194,
+  staticLoc = 195,
+  stringLiteral = 196,
+  stringliteralLoc = 197,
+  switchLoc = 198,
+  symbolicName = 199,
+  symbolicNameLoc = 200,
+  templateArgumentList = 201,
+  templateId = 202,
+  templateLoc = 203,
+  templateParameterList = 204,
+  templateRequiresClause = 205,
+  thisLoc = 206,
+  threadLoc = 207,
+  threadLocalLoc = 208,
+  throwLoc = 209,
+  tildeLoc = 210,
+  trailingReturnType = 211,
+  tryLoc = 212,
+  typeConstraint = 213,
+  typeId = 214,
+  typeIdList = 215,
+  typeLoc = 216,
+  typeQualifierList = 217,
+  typeSpecifier = 218,
+  typeSpecifierList = 219,
+  typeTraitLoc = 220,
+  typedefLoc = 221,
+  typeidLoc = 222,
+  typenameLoc = 223,
+  underlyingTypeLoc = 224,
+  unqualifiedId = 225,
+  usingDeclaratorList = 226,
+  usingLoc = 227,
+  vaArgLoc = 228,
+  virtualLoc = 229,
+  virtualOrAccessLoc = 230,
+  voidLoc = 231,
+  volatileLoc = 232,
+  whileLoc = 233,
+  yieldLoc = 234,
 }
diff --git a/packages/cxx-frontend/src/ASTVisitor.ts b/packages/cxx-frontend/src/ASTVisitor.ts
index 89bc8e0f..59413575 100644
--- a/packages/cxx-frontend/src/ASTVisitor.ts
+++ b/packages/cxx-frontend/src/ASTVisitor.ts
@@ -734,6 +734,18 @@ export abstract class ASTVisitor<Context, Result> {
     context: Context,
   ): Result;
 
+  /**
+   * Visit GenericSelectionExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitGenericSelectionExpression(
+    node: ast.GenericSelectionExpressionAST,
+    context: Context,
+  ): Result;
+
   /**
    * Visit NestedStatementExpression node.
    *
@@ -1334,6 +1346,30 @@ export abstract class ASTVisitor<Context, Result> {
     context: Context,
   ): Result;
 
+  /**
+   * Visit DefaultGenericAssociation node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitDefaultGenericAssociation(
+    node: ast.DefaultGenericAssociationAST,
+    context: Context,
+  ): Result;
+
+  /**
+   * Visit TypeGenericAssociation node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   * @returns The result of the visit.
+   */
+  abstract visitTypeGenericAssociation(
+    node: ast.TypeGenericAssociationAST,
+    context: Context,
+  ): Result;
+
   /**
    * Visit DotDesignator node.
    *
diff --git a/packages/cxx-frontend/src/RecursiveASTVisitor.ts b/packages/cxx-frontend/src/RecursiveASTVisitor.ts
index 4834e138..dc70a78f 100644
--- a/packages/cxx-frontend/src/RecursiveASTVisitor.ts
+++ b/packages/cxx-frontend/src/RecursiveASTVisitor.ts
@@ -845,6 +845,22 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
    */
   visitThisExpression(node: ast.ThisExpressionAST, context: Context): void {}
 
+  /**
+   * Visit a GenericSelectionExpression node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitGenericSelectionExpression(
+    node: ast.GenericSelectionExpressionAST,
+    context: Context,
+  ): void {
+    this.accept(node.getExpression(), context);
+    for (const element of node.getGenericAssociationList()) {
+      this.accept(element, context);
+    }
+  }
+
   /**
    * Visit a NestedStatementExpression node.
    *
@@ -1489,6 +1505,33 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     }
   }
 
+  /**
+   * Visit a DefaultGenericAssociation node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitDefaultGenericAssociation(
+    node: ast.DefaultGenericAssociationAST,
+    context: Context,
+  ): void {
+    this.accept(node.getExpression(), context);
+  }
+
+  /**
+   * Visit a TypeGenericAssociation node.
+   *
+   * @param node The node to visit.
+   * @param context The context.
+   */
+  visitTypeGenericAssociation(
+    node: ast.TypeGenericAssociationAST,
+    context: Context,
+  ): void {
+    this.accept(node.getTypeId(), context);
+    this.accept(node.getExpression(), context);
+  }
+
   /**
    * Visit a DotDesignator node.
    *
diff --git a/scripts/update-tests.mjs b/scripts/update-tests.mjs
index e2a380a8..0b0ce692 100755
--- a/scripts/update-tests.mjs
+++ b/scripts/update-tests.mjs
@@ -26,7 +26,7 @@ const workspacePath = path.join(__dirname, "../");
 const unitTestsPath = path.join(workspacePath, "tests/unit_tests/ast");
 const cxx = path.join(workspacePath, "build/src/frontend/cxx");
 
-const unitTestFilePaths = await glob(`${unitTestsPath}/**/*.cc`);
+const unitTestFilePaths = await glob(`${unitTestsPath}/**/*.{cc,c}`);
 
 async function readLines(path) {
   const unitTestContent = await fs.readFile(path, "utf-8");
@@ -51,8 +51,10 @@ async function updateTest(unitTestPath) {
 
   const fcheck = sourceLines[index]?.includes("-fcheck") ? "-fcheck" : "";
 
+  const lang = unitTestPath.endsWith(".c") ? "-xc" : "";
+
   const ast =
-    await $`${cxx} -verify -ast-dump ${unitTestPath} ${fcheck}`.quiet();
+    await $`${cxx} -verify -ast-dump ${unitTestPath} ${fcheck} ${lang}`.quiet();
 
   const lines = ast.stdout.split("\n");
 
diff --git a/src/mlir/cxx/mlir/codegen.cc b/src/mlir/cxx/mlir/codegen.cc
index 22c18549..3464c615 100644
--- a/src/mlir/cxx/mlir/codegen.cc
+++ b/src/mlir/cxx/mlir/codegen.cc
@@ -177,6 +177,9 @@ struct Codegen::ExpressionVisitor {
   [[nodiscard]] auto operator()(ObjectLiteralExpressionAST* ast)
       -> ExpressionResult;
 
+  [[nodiscard]] auto operator()(GenericSelectionExpressionAST* ast)
+      -> ExpressionResult;
+
   [[nodiscard]] auto operator()(ThisExpressionAST* ast) -> ExpressionResult;
 
   [[nodiscard]] auto operator()(NestedStatementExpressionAST* ast)
@@ -1637,6 +1640,13 @@ auto Codegen::ExpressionVisitor::operator()(ThisExpressionAST* ast)
   return {op};
 }
 
+auto Codegen::ExpressionVisitor::operator()(GenericSelectionExpressionAST* ast)
+    -> ExpressionResult {
+  auto op = gen.emitTodoExpr(ast->firstSourceLocation(),
+                             "GenericSelectionExpressionAST");
+  return {op};
+}
+
 auto Codegen::ExpressionVisitor::operator()(NestedStatementExpressionAST* ast)
     -> ExpressionResult {
   auto op = gen.emitTodoExpr(ast->firstSourceLocation(),
diff --git a/src/parser/cxx/ast.cc b/src/parser/cxx/ast.cc
index f7a5abf8..d0bdf021 100644
--- a/src/parser/cxx/ast.cc
+++ b/src/parser/cxx/ast.cc
@@ -975,6 +975,26 @@ auto ThisExpressionAST::lastSourceLocation() -> SourceLocation {
   return {};
 }
 
+auto GenericSelectionExpressionAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(genericLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(lparenLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(expression)) return loc;
+  if (auto loc = cxx::firstSourceLocation(commaLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(genericAssociationList)) return loc;
+  if (auto loc = cxx::firstSourceLocation(rparenLoc)) return loc;
+  return {};
+}
+
+auto GenericSelectionExpressionAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(rparenLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(genericAssociationList)) return loc;
+  if (auto loc = cxx::lastSourceLocation(commaLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(expression)) return loc;
+  if (auto loc = cxx::lastSourceLocation(lparenLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(genericLoc)) return loc;
+  return {};
+}
+
 auto NestedStatementExpressionAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(lparenLoc)) return loc;
   if (auto loc = cxx::firstSourceLocation(statement)) return loc;
@@ -1773,6 +1793,34 @@ auto ParenInitializerAST::lastSourceLocation() -> SourceLocation {
   return {};
 }
 
+auto DefaultGenericAssociationAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(defaultLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(colonLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(expression)) return loc;
+  return {};
+}
+
+auto DefaultGenericAssociationAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(expression)) return loc;
+  if (auto loc = cxx::lastSourceLocation(colonLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(defaultLoc)) return loc;
+  return {};
+}
+
+auto TypeGenericAssociationAST::firstSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::firstSourceLocation(typeId)) return loc;
+  if (auto loc = cxx::firstSourceLocation(colonLoc)) return loc;
+  if (auto loc = cxx::firstSourceLocation(expression)) return loc;
+  return {};
+}
+
+auto TypeGenericAssociationAST::lastSourceLocation() -> SourceLocation {
+  if (auto loc = cxx::lastSourceLocation(expression)) return loc;
+  if (auto loc = cxx::lastSourceLocation(colonLoc)) return loc;
+  if (auto loc = cxx::lastSourceLocation(typeId)) return loc;
+  return {};
+}
+
 auto DotDesignatorAST::firstSourceLocation() -> SourceLocation {
   if (auto loc = cxx::firstSourceLocation(dotLoc)) return loc;
   if (auto loc = cxx::firstSourceLocation(identifierLoc)) return loc;
@@ -3561,6 +3609,7 @@ std::string_view kASTKindNames[] = {
     "user-defined-string-literal-expression",
     "object-literal-expression",
     "this-expression",
+    "generic-selection-expression",
     "nested-statement-expression",
     "nested-expression",
     "id-expression",
@@ -3612,6 +3661,10 @@ std::string_view kASTKindNames[] = {
     "braced-init-list",
     "paren-initializer",
 
+    // GenericAssociationAST
+    "default-generic-association",
+    "type-generic-association",
+
     // DesignatorAST
     "dot-designator",
     "subscript-designator",
diff --git a/src/parser/cxx/ast.fbs b/src/parser/cxx/ast.fbs
index c982e23e..c94b3b61 100644
--- a/src/parser/cxx/ast.fbs
+++ b/src/parser/cxx/ast.fbs
@@ -137,6 +137,7 @@ union Expression {
   UserDefinedStringLiteralExpression,
   ObjectLiteralExpression,
   ThisExpression,
+  GenericSelectionExpression,
   NestedStatementExpression,
   NestedExpression,
   IdExpression,
@@ -196,6 +197,11 @@ union FunctionBody {
   DeleteFunctionBody,
 }
 
+union GenericAssociation {
+  DefaultGenericAssociation,
+  TypeGenericAssociation,
+}
+
 union LambdaCapture {
   ThisLambdaCapture,
   DerefThisLambdaCapture,
@@ -910,6 +916,15 @@ table ThisExpression /* ExpressionAST */ {
   this_loc: uint32;
 }
 
+table GenericSelectionExpression /* ExpressionAST */ {
+  expression: Expression;
+  generic_association_list: [GenericAssociation];
+  generic_loc: uint32;
+  lparen_loc: uint32;
+  comma_loc: uint32;
+  rparen_loc: uint32;
+}
+
 table NestedStatementExpression /* ExpressionAST */ {
   statement: CompoundStatement;
   lparen_loc: uint32;
@@ -1296,6 +1311,18 @@ table DeleteFunctionBody /* FunctionBodyAST */ {
   semicolon_loc: uint32;
 }
 
+table DefaultGenericAssociation /* GenericAssociationAST */ {
+  expression: Expression;
+  default_loc: uint32;
+  colon_loc: uint32;
+}
+
+table TypeGenericAssociation /* GenericAssociationAST */ {
+  type_id: TypeId;
+  expression: Expression;
+  colon_loc: uint32;
+}
+
 table ThisLambdaCapture /* LambdaCaptureAST */ {
   this_loc: uint32;
 }
diff --git a/src/parser/cxx/ast.h b/src/parser/cxx/ast.h
index d57314b0..9ae171ff 100644
--- a/src/parser/cxx/ast.h
+++ b/src/parser/cxx/ast.h
@@ -210,6 +210,11 @@ class FunctionBodyAST : public AST {
   using AST::AST;
 };
 
+class GenericAssociationAST : public AST {
+ public:
+  using AST::AST;
+};
+
 class LambdaCaptureAST : public AST {
  public:
   using AST::AST;
@@ -1325,6 +1330,25 @@ class ThisExpressionAST final : public ExpressionAST {
   auto lastSourceLocation() -> SourceLocation override;
 };
 
+class GenericSelectionExpressionAST final : public ExpressionAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::GenericSelectionExpression;
+
+  GenericSelectionExpressionAST() : ExpressionAST(Kind) {}
+
+  SourceLocation genericLoc;
+  SourceLocation lparenLoc;
+  ExpressionAST* expression = nullptr;
+  SourceLocation commaLoc;
+  List<GenericAssociationAST*>* genericAssociationList = nullptr;
+  SourceLocation rparenLoc;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
 class NestedStatementExpressionAST final : public ExpressionAST {
  public:
   static constexpr ASTKind Kind = ASTKind::NestedStatementExpression;
@@ -2198,6 +2222,38 @@ class ParenInitializerAST final : public ExpressionAST {
   auto lastSourceLocation() -> SourceLocation override;
 };
 
+class DefaultGenericAssociationAST final : public GenericAssociationAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::DefaultGenericAssociation;
+
+  DefaultGenericAssociationAST() : GenericAssociationAST(Kind) {}
+
+  SourceLocation defaultLoc;
+  SourceLocation colonLoc;
+  ExpressionAST* expression = nullptr;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
+class TypeGenericAssociationAST final : public GenericAssociationAST {
+ public:
+  static constexpr ASTKind Kind = ASTKind::TypeGenericAssociation;
+
+  TypeGenericAssociationAST() : GenericAssociationAST(Kind) {}
+
+  TypeIdAST* typeId = nullptr;
+  SourceLocation colonLoc;
+  ExpressionAST* expression = nullptr;
+
+  void accept(ASTVisitor* visitor) override { visitor->visit(this); }
+
+  auto firstSourceLocation() -> SourceLocation override;
+  auto lastSourceLocation() -> SourceLocation override;
+};
+
 class DotDesignatorAST final : public DesignatorAST {
  public:
   static constexpr ASTKind Kind = ASTKind::DotDesignator;
@@ -4523,6 +4579,9 @@ auto visit(Visitor&& visitor, ExpressionAST* ast) {
     case ThisExpressionAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<ThisExpressionAST*>(ast));
+    case GenericSelectionExpressionAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<GenericSelectionExpressionAST*>(ast));
     case NestedStatementExpressionAST::Kind:
       return std::invoke(std::forward<Visitor>(visitor),
                          static_cast<NestedStatementExpressionAST*>(ast));
@@ -4692,6 +4751,7 @@ template <>
     case UserDefinedStringLiteralExpressionAST::Kind:
     case ObjectLiteralExpressionAST::Kind:
     case ThisExpressionAST::Kind:
+    case GenericSelectionExpressionAST::Kind:
     case NestedStatementExpressionAST::Kind:
     case NestedExpressionAST::Kind:
     case IdExpressionAST::Kind:
@@ -4748,6 +4808,33 @@ template <>
   }  // switch
 }
 
+template <typename Visitor>
+auto visit(Visitor&& visitor, GenericAssociationAST* ast) {
+  switch (ast->kind()) {
+    case DefaultGenericAssociationAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<DefaultGenericAssociationAST*>(ast));
+    case TypeGenericAssociationAST::Kind:
+      return std::invoke(std::forward<Visitor>(visitor),
+                         static_cast<TypeGenericAssociationAST*>(ast));
+    default:
+      cxx_runtime_error("unexpected GenericAssociation");
+  }  // switch
+}
+
+template <>
+[[nodiscard]] inline auto ast_cast<GenericAssociationAST>(AST* ast)
+    -> GenericAssociationAST* {
+  if (!ast) return nullptr;
+  switch (ast->kind()) {
+    case DefaultGenericAssociationAST::Kind:
+    case TypeGenericAssociationAST::Kind:
+      return static_cast<GenericAssociationAST*>(ast);
+    default:
+      return nullptr;
+  }  // switch
+}
+
 template <typename Visitor>
 auto visit(Visitor&& visitor, DesignatorAST* ast) {
   switch (ast->kind()) {
diff --git a/src/parser/cxx/ast_fwd.h b/src/parser/cxx/ast_fwd.h
index 6b458dae..97e52000 100644
--- a/src/parser/cxx/ast_fwd.h
+++ b/src/parser/cxx/ast_fwd.h
@@ -66,6 +66,7 @@ class ExceptionDeclarationAST;
 class ExceptionSpecifierAST;
 class ExpressionAST;
 class FunctionBodyAST;
+class GenericAssociationAST;
 class LambdaCaptureAST;
 class MemInitializerAST;
 class NestedNameSpecifierAST;
@@ -146,6 +147,7 @@ class StringLiteralExpressionAST;
 class UserDefinedStringLiteralExpressionAST;
 class ObjectLiteralExpressionAST;
 class ThisExpressionAST;
+class GenericSelectionExpressionAST;
 class NestedStatementExpressionAST;
 class NestedExpressionAST;
 class IdExpressionAST;
@@ -197,6 +199,10 @@ class EqualInitializerAST;
 class BracedInitListAST;
 class ParenInitializerAST;
 
+// GenericAssociationAST
+class DefaultGenericAssociationAST;
+class TypeGenericAssociationAST;
+
 // DesignatorAST
 class DotDesignatorAST;
 class SubscriptDesignatorAST;
diff --git a/src/parser/cxx/ast_interpreter.cc b/src/parser/cxx/ast_interpreter.cc
index bda122ca..3096b0f4 100644
--- a/src/parser/cxx/ast_interpreter.cc
+++ b/src/parser/cxx/ast_interpreter.cc
@@ -304,6 +304,9 @@ struct ASTInterpreter::ExpressionVisitor {
 
   [[nodiscard]] auto operator()(ThisExpressionAST* ast) -> ExpressionResult;
 
+  [[nodiscard]] auto operator()(GenericSelectionExpressionAST* ast)
+      -> ExpressionResult;
+
   [[nodiscard]] auto operator()(NestedStatementExpressionAST* ast)
       -> ExpressionResult;
 
@@ -1638,6 +1641,11 @@ auto ASTInterpreter::ExpressionVisitor::operator()(ThisExpressionAST* ast)
   return std::nullopt;
 }
 
+auto ASTInterpreter::ExpressionVisitor::operator()(
+    GenericSelectionExpressionAST* ast) -> ExpressionResult {
+  return std::nullopt;
+}
+
 auto ASTInterpreter::ExpressionVisitor::operator()(NestedExpressionAST* ast)
     -> ExpressionResult {
   if (ast->expression) {
diff --git a/src/parser/cxx/ast_kind.h b/src/parser/cxx/ast_kind.h
index 6fa6ccee..4ebbc587 100644
--- a/src/parser/cxx/ast_kind.h
+++ b/src/parser/cxx/ast_kind.h
@@ -92,6 +92,7 @@ enum class ASTKind {
   UserDefinedStringLiteralExpression,
   ObjectLiteralExpression,
   ThisExpression,
+  GenericSelectionExpression,
   NestedStatementExpression,
   NestedExpression,
   IdExpression,
@@ -143,6 +144,10 @@ enum class ASTKind {
   BracedInitList,
   ParenInitializer,
 
+  // GenericAssociationAST
+  DefaultGenericAssociation,
+  TypeGenericAssociation,
+
   // DesignatorAST
   DotDesignator,
   SubscriptDesignator,
diff --git a/src/parser/cxx/ast_pretty_printer.cc b/src/parser/cxx/ast_pretty_printer.cc
index b073b849..3f425998 100644
--- a/src/parser/cxx/ast_pretty_printer.cc
+++ b/src/parser/cxx/ast_pretty_printer.cc
@@ -203,6 +203,8 @@ struct ASTPrettyPrinter::ExpressionVisitor {
 
   void operator()(ThisExpressionAST* ast);
 
+  void operator()(GenericSelectionExpressionAST* ast);
+
   void operator()(NestedStatementExpressionAST* ast);
 
   void operator()(NestedExpressionAST* ast);
@@ -304,6 +306,24 @@ struct ASTPrettyPrinter::ExpressionVisitor {
   void operator()(ParenInitializerAST* ast);
 };
 
+struct ASTPrettyPrinter::GenericAssociationVisitor {
+  ASTPrettyPrinter& accept;
+  [[nodiscard]] auto translationUnit() const -> TranslationUnit* {
+    return accept.unit_;
+  }
+  void space() { accept.space(); }
+  void nospace() { accept.nospace(); }
+  void keepSpace() { accept.keepSpace(); }
+  void newline() { accept.newline(); }
+  void nonewline() { accept.nonewline(); }
+  void indent() { accept.indent(); }
+  void unindent() { accept.unindent(); }
+
+  void operator()(DefaultGenericAssociationAST* ast);
+
+  void operator()(TypeGenericAssociationAST* ast);
+};
+
 struct ASTPrettyPrinter::DesignatorVisitor {
   ASTPrettyPrinter& accept;
   [[nodiscard]] auto translationUnit() const -> TranslationUnit* {
@@ -772,6 +792,11 @@ void ASTPrettyPrinter::operator()(ExpressionAST* ast) {
   visit(ExpressionVisitor{*this}, ast);
 }
 
+void ASTPrettyPrinter::operator()(GenericAssociationAST* ast) {
+  if (!ast) return;
+  visit(GenericAssociationVisitor{*this}, ast);
+}
+
 void ASTPrettyPrinter::operator()(DesignatorAST* ast) {
   if (!ast) return;
   visit(DesignatorVisitor{*this}, ast);
@@ -2289,6 +2314,32 @@ void ASTPrettyPrinter::ExpressionVisitor::operator()(ThisExpressionAST* ast) {
   }
 }
 
+void ASTPrettyPrinter::ExpressionVisitor::operator()(
+    GenericSelectionExpressionAST* ast) {
+  if (ast->genericLoc) {
+    accept.writeToken(ast->genericLoc);
+  }
+  if (ast->lparenLoc) {
+    nospace();
+    accept.writeToken(ast->lparenLoc);
+    nospace();
+  }
+  accept(ast->expression);
+  if (ast->commaLoc) {
+    nospace();
+    accept.writeToken(ast->commaLoc);
+  }
+
+  for (auto it = ast->genericAssociationList; it; it = it->next) {
+    accept(it->value);
+  }
+
+  if (ast->rparenLoc) {
+    nospace();
+    accept.writeToken(ast->rparenLoc);
+  }
+}
+
 void ASTPrettyPrinter::ExpressionVisitor::operator()(
     NestedStatementExpressionAST* ast) {
   if (ast->lparenLoc) {
@@ -3113,6 +3164,28 @@ void ASTPrettyPrinter::ExpressionVisitor::operator()(ParenInitializerAST* ast) {
   }
 }
 
+void ASTPrettyPrinter::GenericAssociationVisitor::operator()(
+    DefaultGenericAssociationAST* ast) {
+  if (ast->defaultLoc) {
+    accept.writeToken(ast->defaultLoc);
+  }
+  if (ast->colonLoc) {
+    nospace();
+    accept.writeToken(ast->colonLoc);
+  }
+  accept(ast->expression);
+}
+
+void ASTPrettyPrinter::GenericAssociationVisitor::operator()(
+    TypeGenericAssociationAST* ast) {
+  accept(ast->typeId);
+  if (ast->colonLoc) {
+    nospace();
+    accept.writeToken(ast->colonLoc);
+  }
+  accept(ast->expression);
+}
+
 void ASTPrettyPrinter::DesignatorVisitor::operator()(DotDesignatorAST* ast) {
   if (ast->dotLoc) {
     nospace();
diff --git a/src/parser/cxx/ast_pretty_printer.h b/src/parser/cxx/ast_pretty_printer.h
index 0eacb679..5ea74caa 100644
--- a/src/parser/cxx/ast_pretty_printer.h
+++ b/src/parser/cxx/ast_pretty_printer.h
@@ -49,6 +49,7 @@ class ASTPrettyPrinter {
   void operator()(DeclarationAST* ast);
   void operator()(StatementAST* ast);
   void operator()(ExpressionAST* ast);
+  void operator()(GenericAssociationAST* ast);
   void operator()(DesignatorAST* ast);
   void operator()(TemplateParameterAST* ast);
   void operator()(SpecifierAST* ast);
@@ -101,6 +102,7 @@ class ASTPrettyPrinter {
   struct DeclarationVisitor;
   struct StatementVisitor;
   struct ExpressionVisitor;
+  struct GenericAssociationVisitor;
   struct DesignatorVisitor;
   struct TemplateParameterVisitor;
   struct SpecifierVisitor;
diff --git a/src/parser/cxx/ast_printer.cc b/src/parser/cxx/ast_printer.cc
index ed21e206..fdb6946b 100644
--- a/src/parser/cxx/ast_printer.cc
+++ b/src/parser/cxx/ast_printer.cc
@@ -841,6 +841,25 @@ void ASTPrinter::visit(ThisExpressionAST* ast) {
   out_ << "\n";
 }
 
+void ASTPrinter::visit(GenericSelectionExpressionAST* ast) {
+  out_ << "generic-selection-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
+  accept(ast->expression, "expression");
+  if (ast->genericAssociationList) {
+    ++indent_;
+    out_ << std::format("{:{}}", "", indent_ * 2);
+    out_ << std::format("{}\n", "generic-association-list");
+    for (auto node : ListView{ast->genericAssociationList}) {
+      accept(node);
+    }
+    --indent_;
+  }
+}
+
 void ASTPrinter::visit(NestedStatementExpressionAST* ast) {
   out_ << "nested-statement-expression";
   if (ast->type) {
@@ -1588,6 +1607,17 @@ void ASTPrinter::visit(ParenInitializerAST* ast) {
   }
 }
 
+void ASTPrinter::visit(DefaultGenericAssociationAST* ast) {
+  out_ << std::format("{}\n", "default-generic-association");
+  accept(ast->expression, "expression");
+}
+
+void ASTPrinter::visit(TypeGenericAssociationAST* ast) {
+  out_ << std::format("{}\n", "type-generic-association");
+  accept(ast->typeId, "type-id");
+  accept(ast->expression, "expression");
+}
+
 void ASTPrinter::visit(DotDesignatorAST* ast) {
   out_ << std::format("{}\n", "dot-designator");
   accept(ast->identifier, "identifier");
diff --git a/src/parser/cxx/ast_printer.h b/src/parser/cxx/ast_printer.h
index 9dd408bb..c4f09603 100644
--- a/src/parser/cxx/ast_printer.h
+++ b/src/parser/cxx/ast_printer.h
@@ -106,6 +106,7 @@ class ASTPrinter : ASTVisitor {
   void visit(UserDefinedStringLiteralExpressionAST* ast) override;
   void visit(ObjectLiteralExpressionAST* ast) override;
   void visit(ThisExpressionAST* ast) override;
+  void visit(GenericSelectionExpressionAST* ast) override;
   void visit(NestedStatementExpressionAST* ast) override;
   void visit(NestedExpressionAST* ast) override;
   void visit(IdExpressionAST* ast) override;
@@ -157,6 +158,9 @@ class ASTPrinter : ASTVisitor {
   void visit(BracedInitListAST* ast) override;
   void visit(ParenInitializerAST* ast) override;
 
+  void visit(DefaultGenericAssociationAST* ast) override;
+  void visit(TypeGenericAssociationAST* ast) override;
+
   void visit(DotDesignatorAST* ast) override;
   void visit(SubscriptDesignatorAST* ast) override;
 
diff --git a/src/parser/cxx/ast_rewriter.cc b/src/parser/cxx/ast_rewriter.cc
index 9d365a08..d8b130a9 100644
--- a/src/parser/cxx/ast_rewriter.cc
+++ b/src/parser/cxx/ast_rewriter.cc
@@ -268,6 +268,9 @@ struct ASTRewriter::ExpressionVisitor {
 
   [[nodiscard]] auto operator()(ThisExpressionAST* ast) -> ExpressionAST*;
 
+  [[nodiscard]] auto operator()(GenericSelectionExpressionAST* ast)
+      -> ExpressionAST*;
+
   [[nodiscard]] auto operator()(NestedStatementExpressionAST* ast)
       -> ExpressionAST*;
 
@@ -383,6 +386,24 @@ struct ASTRewriter::ExpressionVisitor {
   [[nodiscard]] auto operator()(ParenInitializerAST* ast) -> ExpressionAST*;
 };
 
+struct ASTRewriter::GenericAssociationVisitor {
+  ASTRewriter& rewrite;
+  [[nodiscard]] auto translationUnit() const -> TranslationUnit* {
+    return rewrite.unit_;
+  }
+
+  [[nodiscard]] auto control() const -> Control* { return rewrite.control(); }
+  [[nodiscard]] auto arena() const -> Arena* { return rewrite.arena(); }
+  [[nodiscard]] auto rewriter() const -> ASTRewriter* { return &rewrite; }
+  [[nodiscard]] auto binder() const -> Binder* { return &rewrite.binder_; }
+
+  [[nodiscard]] auto operator()(DefaultGenericAssociationAST* ast)
+      -> GenericAssociationAST*;
+
+  [[nodiscard]] auto operator()(TypeGenericAssociationAST* ast)
+      -> GenericAssociationAST*;
+};
+
 struct ASTRewriter::DesignatorVisitor {
   ASTRewriter& rewrite;
   [[nodiscard]] auto translationUnit() const -> TranslationUnit* {
@@ -505,10 +526,10 @@ struct ASTRewriter::SpecifierVisitor {
 
   [[nodiscard]] auto operator()(VolatileQualifierAST* ast) -> SpecifierAST*;
 
-  [[nodiscard]] auto operator()(RestrictQualifierAST* ast) -> SpecifierAST*;
-
   [[nodiscard]] auto operator()(AtomicQualifierAST* ast) -> SpecifierAST*;
 
+  [[nodiscard]] auto operator()(RestrictQualifierAST* ast) -> SpecifierAST*;
+
   [[nodiscard]] auto operator()(EnumSpecifierAST* ast) -> SpecifierAST*;
 
   [[nodiscard]] auto operator()(ClassSpecifierAST* ast) -> SpecifierAST*;
@@ -857,6 +878,12 @@ auto ASTRewriter::operator()(ExpressionAST* ast) -> ExpressionAST* {
   return expr;
 }
 
+auto ASTRewriter::operator()(GenericAssociationAST* ast)
+    -> GenericAssociationAST* {
+  if (!ast) return {};
+  return visit(GenericAssociationVisitor{*this}, ast);
+}
+
 auto ASTRewriter::operator()(DesignatorAST* ast) -> DesignatorAST* {
   if (!ast) return {};
   return visit(DesignatorVisitor{*this}, ast);
@@ -2438,6 +2465,29 @@ auto ASTRewriter::ExpressionVisitor::operator()(ThisExpressionAST* ast)
   return copy;
 }
 
+auto ASTRewriter::ExpressionVisitor::operator()(
+    GenericSelectionExpressionAST* ast) -> ExpressionAST* {
+  auto copy = make_node<GenericSelectionExpressionAST>(arena());
+
+  copy->valueCategory = ast->valueCategory;
+  copy->type = ast->type;
+  copy->genericLoc = ast->genericLoc;
+  copy->lparenLoc = ast->lparenLoc;
+  copy->expression = rewrite(ast->expression);
+  copy->commaLoc = ast->commaLoc;
+
+  for (auto genericAssociationList = &copy->genericAssociationList;
+       auto node : ListView{ast->genericAssociationList}) {
+    auto value = rewrite(node);
+    *genericAssociationList = make_list_node(arena(), value);
+    genericAssociationList = &(*genericAssociationList)->next;
+  }
+
+  copy->rparenLoc = ast->rparenLoc;
+
+  return copy;
+}
+
 auto ASTRewriter::ExpressionVisitor::operator()(
     NestedStatementExpressionAST* ast) -> ExpressionAST* {
   auto copy = make_node<NestedStatementExpressionAST>(arena());
@@ -3359,6 +3409,28 @@ auto ASTRewriter::ExpressionVisitor::operator()(ParenInitializerAST* ast)
   return copy;
 }
 
+auto ASTRewriter::GenericAssociationVisitor::operator()(
+    DefaultGenericAssociationAST* ast) -> GenericAssociationAST* {
+  auto copy = make_node<DefaultGenericAssociationAST>(arena());
+
+  copy->defaultLoc = ast->defaultLoc;
+  copy->colonLoc = ast->colonLoc;
+  copy->expression = rewrite(ast->expression);
+
+  return copy;
+}
+
+auto ASTRewriter::GenericAssociationVisitor::operator()(
+    TypeGenericAssociationAST* ast) -> GenericAssociationAST* {
+  auto copy = make_node<TypeGenericAssociationAST>(arena());
+
+  copy->typeId = rewrite(ast->typeId);
+  copy->colonLoc = ast->colonLoc;
+  copy->expression = rewrite(ast->expression);
+
+  return copy;
+}
+
 auto ASTRewriter::DesignatorVisitor::operator()(DotDesignatorAST* ast)
     -> DesignatorAST* {
   auto copy = make_node<DotDesignatorAST>(arena());
@@ -3809,20 +3881,20 @@ auto ASTRewriter::SpecifierVisitor::operator()(VolatileQualifierAST* ast)
   return copy;
 }
 
-auto ASTRewriter::SpecifierVisitor::operator()(RestrictQualifierAST* ast)
+auto ASTRewriter::SpecifierVisitor::operator()(AtomicQualifierAST* ast)
     -> SpecifierAST* {
-  auto copy = make_node<RestrictQualifierAST>(arena());
+  auto copy = make_node<AtomicQualifierAST>(arena());
 
-  copy->restrictLoc = ast->restrictLoc;
+  copy->atomicLoc = ast->atomicLoc;
 
   return copy;
 }
 
-auto ASTRewriter::SpecifierVisitor::operator()(AtomicQualifierAST* ast)
+auto ASTRewriter::SpecifierVisitor::operator()(RestrictQualifierAST* ast)
     -> SpecifierAST* {
-  auto copy = make_node<AtomicQualifierAST>(arena());
+  auto copy = make_node<RestrictQualifierAST>(arena());
 
-  copy->atomicLoc = ast->atomicLoc;
+  copy->restrictLoc = ast->restrictLoc;
 
   return copy;
 }
diff --git a/src/parser/cxx/ast_rewriter.h b/src/parser/cxx/ast_rewriter.h
index e4c63230..8044f010 100644
--- a/src/parser/cxx/ast_rewriter.h
+++ b/src/parser/cxx/ast_rewriter.h
@@ -64,6 +64,8 @@ class ASTRewriter {
   [[nodiscard]] auto operator()(DeclarationAST* ast) -> DeclarationAST*;
   [[nodiscard]] auto operator()(StatementAST* ast) -> StatementAST*;
   [[nodiscard]] auto operator()(ExpressionAST* ast) -> ExpressionAST*;
+  [[nodiscard]] auto operator()(GenericAssociationAST* ast)
+      -> GenericAssociationAST*;
   [[nodiscard]] auto operator()(DesignatorAST* ast) -> DesignatorAST*;
   [[nodiscard]] auto operator()(TemplateParameterAST* ast)
       -> TemplateParameterAST*;
@@ -131,6 +133,7 @@ class ASTRewriter {
   struct DeclarationVisitor;
   struct StatementVisitor;
   struct ExpressionVisitor;
+  struct GenericAssociationVisitor;
   struct DesignatorVisitor;
   struct TemplateParameterVisitor;
   struct SpecifierVisitor;
diff --git a/src/parser/cxx/ast_slot.cc b/src/parser/cxx/ast_slot.cc
index f0edafec..d2b77e40 100644
--- a/src/parser/cxx/ast_slot.cc
+++ b/src/parser/cxx/ast_slot.cc
@@ -138,6 +138,8 @@ std::string_view kMemberSlotNames[] = {
     "forLoc",
     "friendLoc",
     "functionBody",
+    "genericAssociationList",
+    "genericLoc",
     "globalModuleFragment",
     "gnuAtributeList",
     "gnuAttributeList",
@@ -306,12 +308,12 @@ void ASTSlot::visit(ModuleUnitAST* ast) {
     case 0:  // globalModuleFragment
       value_ = reinterpret_cast<std::intptr_t>(ast->globalModuleFragment);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{88};
+      slotNameIndex_ = SlotNameIndex{90};
       break;
     case 1:  // moduleDeclaration
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleDeclaration);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{134};
+      slotNameIndex_ = SlotNameIndex{136};
       break;
     case 2:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -321,7 +323,7 @@ void ASTSlot::visit(ModuleUnitAST* ast) {
     case 3:  // privateModuleFragment
       value_ = reinterpret_cast<std::intptr_t>(ast->privateModuleFragment);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{159};
+      slotNameIndex_ = SlotNameIndex{161};
       break;
   }  // switch
 
@@ -343,17 +345,17 @@ void ASTSlot::visit(SimpleDeclarationAST* ast) {
     case 2:  // initDeclaratorList
       value_ = reinterpret_cast<std::intptr_t>(ast->initDeclaratorList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{106};
+      slotNameIndex_ = SlotNameIndex{108};
       break;
     case 3:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 4:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -380,22 +382,22 @@ void ASTSlot::visit(AsmDeclarationAST* ast) {
     case 3:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 4:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 5:  // outputOperandList
       value_ = reinterpret_cast<std::intptr_t>(ast->outputOperandList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{155};
+      slotNameIndex_ = SlotNameIndex{157};
       break;
     case 6:  // inputOperandList
       value_ = reinterpret_cast<std::intptr_t>(ast->inputOperandList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{109};
+      slotNameIndex_ = SlotNameIndex{111};
       break;
     case 7:  // clobberList
       value_ = reinterpret_cast<std::intptr_t>(ast->clobberList);
@@ -405,22 +407,22 @@ void ASTSlot::visit(AsmDeclarationAST* ast) {
     case 8:  // gotoLabelList
       value_ = reinterpret_cast<std::intptr_t>(ast->gotoLabelList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{91};
+      slotNameIndex_ = SlotNameIndex{93};
       break;
     case 9:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 10:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 11:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -432,12 +434,12 @@ void ASTSlot::visit(NamespaceAliasDefinitionAST* ast) {
     case 0:  // namespaceLoc
       value_ = ast->namespaceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{140};
+      slotNameIndex_ = SlotNameIndex{142};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // equalLoc
       value_ = ast->equalLoc.index();
@@ -447,22 +449,22 @@ void ASTSlot::visit(NamespaceAliasDefinitionAST* ast) {
     case 3:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 6:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -474,17 +476,17 @@ void ASTSlot::visit(UsingDeclarationAST* ast) {
     case 0:  // usingLoc
       value_ = ast->usingLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{225};
+      slotNameIndex_ = SlotNameIndex{227};
       break;
     case 1:  // usingDeclaratorList
       value_ = reinterpret_cast<std::intptr_t>(ast->usingDeclaratorList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{224};
+      slotNameIndex_ = SlotNameIndex{226};
       break;
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -496,7 +498,7 @@ void ASTSlot::visit(UsingEnumDeclarationAST* ast) {
     case 0:  // usingLoc
       value_ = ast->usingLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{225};
+      slotNameIndex_ = SlotNameIndex{227};
       break;
     case 1:  // enumTypeSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->enumTypeSpecifier);
@@ -506,7 +508,7 @@ void ASTSlot::visit(UsingEnumDeclarationAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -523,27 +525,27 @@ void ASTSlot::visit(UsingDirectiveAST* ast) {
     case 1:  // usingLoc
       value_ = ast->usingLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{225};
+      slotNameIndex_ = SlotNameIndex{227};
       break;
     case 2:  // namespaceLoc
       value_ = ast->namespaceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{140};
+      slotNameIndex_ = SlotNameIndex{142};
       break;
     case 3:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -555,12 +557,12 @@ void ASTSlot::visit(StaticAssertDeclarationAST* ast) {
     case 0:  // staticAssertLoc
       value_ = ast->staticAssertLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{192};
+      slotNameIndex_ = SlotNameIndex{194};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -575,22 +577,22 @@ void ASTSlot::visit(StaticAssertDeclarationAST* ast) {
     case 4:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 5:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -602,12 +604,12 @@ void ASTSlot::visit(AliasDeclarationAST* ast) {
     case 0:  // usingLoc
       value_ = ast->usingLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{225};
+      slotNameIndex_ = SlotNameIndex{227};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -622,22 +624,22 @@ void ASTSlot::visit(AliasDeclarationAST* ast) {
     case 4:  // gnuAttributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->gnuAttributeList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{90};
+      slotNameIndex_ = SlotNameIndex{92};
       break;
     case 5:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 6:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 7:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -664,12 +666,12 @@ void ASTSlot::visit(OpaqueEnumDeclarationAST* ast) {
     case 3:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -679,7 +681,7 @@ void ASTSlot::visit(OpaqueEnumDeclarationAST* ast) {
     case 6:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 7:  // emicolonLoc
       value_ = ast->emicolonLoc.index();
@@ -711,7 +713,7 @@ void ASTSlot::visit(FunctionDefinitionAST* ast) {
     case 3:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 4:  // functionBody
       value_ = reinterpret_cast<std::intptr_t>(ast->functionBody);
@@ -728,27 +730,27 @@ void ASTSlot::visit(TemplateDeclarationAST* ast) {
     case 0:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // templateParameterList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateParameterList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{202};
+      slotNameIndex_ = SlotNameIndex{204};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 4:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 5:  // declaration
       value_ = reinterpret_cast<std::intptr_t>(ast->declaration);
@@ -770,7 +772,7 @@ void ASTSlot::visit(ConceptDefinitionAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // equalLoc
       value_ = ast->equalLoc.index();
@@ -785,12 +787,12 @@ void ASTSlot::visit(ConceptDefinitionAST* ast) {
     case 4:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 5:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -807,22 +809,22 @@ void ASTSlot::visit(DeductionGuideAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 3:  // parameterDeclarationClause
       value_ = reinterpret_cast<std::intptr_t>(ast->parameterDeclarationClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{156};
+      slotNameIndex_ = SlotNameIndex{158};
       break;
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // arrowLoc
       value_ = ast->arrowLoc.index();
@@ -832,17 +834,17 @@ void ASTSlot::visit(DeductionGuideAST* ast) {
     case 6:  // templateId
       value_ = reinterpret_cast<std::intptr_t>(ast->templateId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{200};
+      slotNameIndex_ = SlotNameIndex{202};
       break;
     case 7:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 8:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -859,7 +861,7 @@ void ASTSlot::visit(ExplicitInstantiationAST* ast) {
     case 1:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 2:  // declaration
       value_ = reinterpret_cast<std::intptr_t>(ast->declaration);
@@ -898,7 +900,7 @@ void ASTSlot::visit(ExportCompoundDeclarationAST* ast) {
     case 1:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 2:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -908,7 +910,7 @@ void ASTSlot::visit(ExportCompoundDeclarationAST* ast) {
     case 3:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
   }  // switch
 
@@ -925,12 +927,12 @@ void ASTSlot::visit(LinkageSpecificationAST* ast) {
     case 1:  // stringliteralLoc
       value_ = ast->stringliteralLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{195};
+      slotNameIndex_ = SlotNameIndex{197};
       break;
     case 2:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 3:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -940,12 +942,12 @@ void ASTSlot::visit(LinkageSpecificationAST* ast) {
     case 4:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
     case 5:  // stringLiteral
       value_ = reinterpret_cast<std::intptr_t>(ast->stringLiteral);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{194};
+      slotNameIndex_ = SlotNameIndex{196};
       break;
   }  // switch
 
@@ -957,12 +959,12 @@ void ASTSlot::visit(NamespaceDefinitionAST* ast) {
     case 0:  // inlineLoc
       value_ = ast->inlineLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{108};
+      slotNameIndex_ = SlotNameIndex{110};
       break;
     case 1:  // namespaceLoc
       value_ = ast->namespaceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{140};
+      slotNameIndex_ = SlotNameIndex{142};
       break;
     case 2:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -973,12 +975,12 @@ void ASTSlot::visit(NamespaceDefinitionAST* ast) {
       value_ =
           reinterpret_cast<std::intptr_t>(ast->nestedNamespaceSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{142};
+      slotNameIndex_ = SlotNameIndex{144};
       break;
     case 4:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 5:  // extraAttributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->extraAttributeList);
@@ -988,7 +990,7 @@ void ASTSlot::visit(NamespaceDefinitionAST* ast) {
     case 6:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 7:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -998,17 +1000,17 @@ void ASTSlot::visit(NamespaceDefinitionAST* ast) {
     case 8:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
     case 9:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 10:  // isInline
       value_ = std::intptr_t(ast->isInline != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{111};
+      slotNameIndex_ = SlotNameIndex{113};
       break;
   }  // switch
 
@@ -1020,7 +1022,7 @@ void ASTSlot::visit(EmptyDeclarationAST* ast) {
     case 0:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1037,7 +1039,7 @@ void ASTSlot::visit(AttributeDeclarationAST* ast) {
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1049,12 +1051,12 @@ void ASTSlot::visit(ModuleImportDeclarationAST* ast) {
     case 0:  // importLoc
       value_ = ast->importLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{103};
+      slotNameIndex_ = SlotNameIndex{105};
       break;
     case 1:  // importName
       value_ = reinterpret_cast<std::intptr_t>(ast->importName);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{104};
+      slotNameIndex_ = SlotNameIndex{106};
       break;
     case 2:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -1064,7 +1066,7 @@ void ASTSlot::visit(ModuleImportDeclarationAST* ast) {
     case 3:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1081,12 +1083,12 @@ void ASTSlot::visit(ParameterDeclarationAST* ast) {
     case 1:  // thisLoc
       value_ = ast->thisLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{204};
+      slotNameIndex_ = SlotNameIndex{206};
       break;
     case 2:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 3:  // declarator
       value_ = reinterpret_cast<std::intptr_t>(ast->declarator);
@@ -1106,17 +1108,17 @@ void ASTSlot::visit(ParameterDeclarationAST* ast) {
     case 6:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 7:  // isThisIntroduced
       value_ = std::intptr_t(ast->isThisIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{117};
+      slotNameIndex_ = SlotNameIndex{119};
       break;
     case 8:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -1162,12 +1164,12 @@ void ASTSlot::visit(StructuredBindingDeclarationAST* ast) {
     case 2:  // refQualifierLoc
       value_ = ast->refQualifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{171};
+      slotNameIndex_ = SlotNameIndex{173};
       break;
     case 3:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 4:  // bindingList
       value_ = reinterpret_cast<std::intptr_t>(ast->bindingList);
@@ -1177,17 +1179,17 @@ void ASTSlot::visit(StructuredBindingDeclarationAST* ast) {
     case 5:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 6:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 7:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1199,17 +1201,17 @@ void ASTSlot::visit(AsmOperandAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // symbolicNameLoc
       value_ = ast->symbolicNameLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{198};
+      slotNameIndex_ = SlotNameIndex{200};
       break;
     case 2:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 3:  // constraintLiteralLoc
       value_ = ast->constraintLiteralLoc.index();
@@ -1219,7 +1221,7 @@ void ASTSlot::visit(AsmOperandAST* ast) {
     case 4:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 5:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -1229,12 +1231,12 @@ void ASTSlot::visit(AsmOperandAST* ast) {
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // symbolicName
       value_ = reinterpret_cast<std::intptr_t>(ast->symbolicName);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{197};
+      slotNameIndex_ = SlotNameIndex{199};
       break;
     case 8:  // constraintLiteral
       value_ = reinterpret_cast<std::intptr_t>(ast->constraintLiteral);
@@ -1251,12 +1253,12 @@ void ASTSlot::visit(AsmQualifierAST* ast) {
     case 0:  // qualifierLoc
       value_ = ast->qualifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{162};
+      slotNameIndex_ = SlotNameIndex{164};
       break;
     case 1:  // qualifier
       value_ = std::intptr_t(ast->qualifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{161};
+      slotNameIndex_ = SlotNameIndex{163};
       break;
   }  // switch
 
@@ -1268,12 +1270,12 @@ void ASTSlot::visit(AsmClobberAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1285,12 +1287,12 @@ void ASTSlot::visit(AsmGotoLabelAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -1302,7 +1304,7 @@ void ASTSlot::visit(LabeledStatementAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -1312,7 +1314,7 @@ void ASTSlot::visit(LabeledStatementAST* ast) {
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -1368,7 +1370,7 @@ void ASTSlot::visit(ExpressionStatementAST* ast) {
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1380,17 +1382,17 @@ void ASTSlot::visit(CompoundStatementAST* ast) {
     case 0:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 1:  // statementList
       value_ = reinterpret_cast<std::intptr_t>(ast->statementList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{191};
+      slotNameIndex_ = SlotNameIndex{193};
       break;
     case 2:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
   }  // switch
 
@@ -1402,7 +1404,7 @@ void ASTSlot::visit(IfStatementAST* ast) {
     case 0:  // ifLoc
       value_ = ast->ifLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{100};
+      slotNameIndex_ = SlotNameIndex{102};
       break;
     case 1:  // constexprLoc
       value_ = ast->constexprLoc.index();
@@ -1412,12 +1414,12 @@ void ASTSlot::visit(IfStatementAST* ast) {
     case 2:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 3:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 4:  // condition
       value_ = reinterpret_cast<std::intptr_t>(ast->condition);
@@ -1427,12 +1429,12 @@ void ASTSlot::visit(IfStatementAST* ast) {
     case 5:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 6:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 7:  // elseLoc
       value_ = ast->elseLoc.index();
@@ -1454,7 +1456,7 @@ void ASTSlot::visit(ConstevalIfStatementAST* ast) {
     case 0:  // ifLoc
       value_ = ast->ifLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{100};
+      slotNameIndex_ = SlotNameIndex{102};
       break;
     case 1:  // exclaimLoc
       value_ = ast->exclaimLoc.index();
@@ -1469,7 +1471,7 @@ void ASTSlot::visit(ConstevalIfStatementAST* ast) {
     case 3:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 4:  // elseLoc
       value_ = ast->elseLoc.index();
@@ -1484,7 +1486,7 @@ void ASTSlot::visit(ConstevalIfStatementAST* ast) {
     case 6:  // isNot
       value_ = std::intptr_t(ast->isNot != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{112};
+      slotNameIndex_ = SlotNameIndex{114};
       break;
   }  // switch
 
@@ -1496,17 +1498,17 @@ void ASTSlot::visit(SwitchStatementAST* ast) {
     case 0:  // switchLoc
       value_ = ast->switchLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{196};
+      slotNameIndex_ = SlotNameIndex{198};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 3:  // condition
       value_ = reinterpret_cast<std::intptr_t>(ast->condition);
@@ -1516,12 +1518,12 @@ void ASTSlot::visit(SwitchStatementAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -1533,12 +1535,12 @@ void ASTSlot::visit(WhileStatementAST* ast) {
     case 0:  // whileLoc
       value_ = ast->whileLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{231};
+      slotNameIndex_ = SlotNameIndex{233};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // condition
       value_ = reinterpret_cast<std::intptr_t>(ast->condition);
@@ -1548,12 +1550,12 @@ void ASTSlot::visit(WhileStatementAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 4:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -1570,17 +1572,17 @@ void ASTSlot::visit(DoStatementAST* ast) {
     case 1:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 2:  // whileLoc
       value_ = ast->whileLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{231};
+      slotNameIndex_ = SlotNameIndex{233};
       break;
     case 3:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 4:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -1590,12 +1592,12 @@ void ASTSlot::visit(DoStatementAST* ast) {
     case 5:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 6:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1612,17 +1614,17 @@ void ASTSlot::visit(ForRangeStatementAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 3:  // rangeDeclaration
       value_ = reinterpret_cast<std::intptr_t>(ast->rangeDeclaration);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{164};
+      slotNameIndex_ = SlotNameIndex{166};
       break;
     case 4:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -1632,17 +1634,17 @@ void ASTSlot::visit(ForRangeStatementAST* ast) {
     case 5:  // rangeInitializer
       value_ = reinterpret_cast<std::intptr_t>(ast->rangeInitializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{165};
+      slotNameIndex_ = SlotNameIndex{167};
       break;
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -1659,12 +1661,12 @@ void ASTSlot::visit(ForStatementAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 3:  // condition
       value_ = reinterpret_cast<std::intptr_t>(ast->condition);
@@ -1674,7 +1676,7 @@ void ASTSlot::visit(ForStatementAST* ast) {
     case 4:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 5:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -1684,12 +1686,12 @@ void ASTSlot::visit(ForStatementAST* ast) {
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -1706,7 +1708,7 @@ void ASTSlot::visit(BreakStatementAST* ast) {
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1723,7 +1725,7 @@ void ASTSlot::visit(ContinueStatementAST* ast) {
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1735,7 +1737,7 @@ void ASTSlot::visit(ReturnStatementAST* ast) {
     case 0:  // returnLoc
       value_ = ast->returnLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{177};
+      slotNameIndex_ = SlotNameIndex{179};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -1745,7 +1747,7 @@ void ASTSlot::visit(ReturnStatementAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1767,7 +1769,7 @@ void ASTSlot::visit(CoroutineReturnStatementAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -1779,22 +1781,22 @@ void ASTSlot::visit(GotoStatementAST* ast) {
     case 0:  // gotoLoc
       value_ = ast->gotoLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{92};
+      slotNameIndex_ = SlotNameIndex{94};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 3:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -1818,17 +1820,17 @@ void ASTSlot::visit(TryBlockStatementAST* ast) {
     case 0:  // tryLoc
       value_ = ast->tryLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{210};
+      slotNameIndex_ = SlotNameIndex{212};
       break;
     case 1:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 2:  // handlerList
       value_ = reinterpret_cast<std::intptr_t>(ast->handlerList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{94};
+      slotNameIndex_ = SlotNameIndex{96};
       break;
   }  // switch
 
@@ -1840,7 +1842,7 @@ void ASTSlot::visit(GeneratedLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
   }  // switch
 
@@ -1852,12 +1854,12 @@ void ASTSlot::visit(CharLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1869,12 +1871,12 @@ void ASTSlot::visit(BoolLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // isTrue
       value_ = std::intptr_t(ast->isTrue != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{118};
+      slotNameIndex_ = SlotNameIndex{120};
       break;
   }  // switch
 
@@ -1886,12 +1888,12 @@ void ASTSlot::visit(IntLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1903,12 +1905,12 @@ void ASTSlot::visit(FloatLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1920,12 +1922,12 @@ void ASTSlot::visit(NullptrLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = std::intptr_t(ast->literal);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1937,12 +1939,12 @@ void ASTSlot::visit(StringLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1954,12 +1956,12 @@ void ASTSlot::visit(UserDefinedStringLiteralExpressionAST* ast) {
     case 0:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 1:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -1971,17 +1973,17 @@ void ASTSlot::visit(ObjectLiteralExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 3:  // bracedInitList
       value_ = reinterpret_cast<std::intptr_t>(ast->bracedInitList);
@@ -1998,29 +2000,66 @@ void ASTSlot::visit(ThisExpressionAST* ast) {
     case 0:  // thisLoc
       value_ = ast->thisLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{204};
+      slotNameIndex_ = SlotNameIndex{206};
       break;
   }  // switch
 
   slotCount_ = 1;
 }
 
+void ASTSlot::visit(GenericSelectionExpressionAST* ast) {
+  switch (slot_) {
+    case 0:  // genericLoc
+      value_ = ast->genericLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{89};
+      break;
+    case 1:  // lparenLoc
+      value_ = ast->lparenLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{133};
+      break;
+    case 2:  // expression
+      value_ = reinterpret_cast<std::intptr_t>(ast->expression);
+      slotKind_ = ASTSlotKind::kNode;
+      slotNameIndex_ = SlotNameIndex{78};
+      break;
+    case 3:  // commaLoc
+      value_ = ast->commaLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{37};
+      break;
+    case 4:  // genericAssociationList
+      value_ = reinterpret_cast<std::intptr_t>(ast->genericAssociationList);
+      slotKind_ = ASTSlotKind::kNodeList;
+      slotNameIndex_ = SlotNameIndex{88};
+      break;
+    case 5:  // rparenLoc
+      value_ = ast->rparenLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{182};
+      break;
+  }  // switch
+
+  slotCount_ = 6;
+}
+
 void ASTSlot::visit(NestedStatementExpressionAST* ast) {
   switch (slot_) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2032,7 +2071,7 @@ void ASTSlot::visit(NestedExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2042,7 +2081,7 @@ void ASTSlot::visit(NestedExpressionAST* ast) {
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2054,22 +2093,22 @@ void ASTSlot::visit(IdExpressionAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 2:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 3:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -2081,7 +2120,7 @@ void ASTSlot::visit(LambdaExpressionAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // captureDefaultLoc
       value_ = ast->captureDefaultLoc.index();
@@ -2096,52 +2135,52 @@ void ASTSlot::visit(LambdaExpressionAST* ast) {
     case 3:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 4:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 5:  // templateParameterList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateParameterList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{202};
+      slotNameIndex_ = SlotNameIndex{204};
       break;
     case 6:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 7:  // templateRequiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->templateRequiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{203};
+      slotNameIndex_ = SlotNameIndex{205};
       break;
     case 8:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 9:  // parameterDeclarationClause
       value_ = reinterpret_cast<std::intptr_t>(ast->parameterDeclarationClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{156};
+      slotNameIndex_ = SlotNameIndex{158};
       break;
     case 10:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 11:  // gnuAtributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->gnuAtributeList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{89};
+      slotNameIndex_ = SlotNameIndex{91};
       break;
     case 12:  // lambdaSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->lambdaSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{121};
+      slotNameIndex_ = SlotNameIndex{123};
       break;
     case 13:  // exceptionSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->exceptionSpecifier);
@@ -2156,17 +2195,17 @@ void ASTSlot::visit(LambdaExpressionAST* ast) {
     case 15:  // trailingReturnType
       value_ = reinterpret_cast<std::intptr_t>(ast->trailingReturnType);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{209};
+      slotNameIndex_ = SlotNameIndex{211};
       break;
     case 16:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 17:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 18:  // captureDefault
       value_ = std::intptr_t(ast->captureDefault);
@@ -2183,17 +2222,17 @@ void ASTSlot::visit(FoldExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // leftExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->leftExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{125};
+      slotNameIndex_ = SlotNameIndex{127};
       break;
     case 2:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 3:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -2208,17 +2247,17 @@ void ASTSlot::visit(FoldExpressionAST* ast) {
     case 5:  // rightExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->rightExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{178};
+      slotNameIndex_ = SlotNameIndex{180};
       break;
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
     case 8:  // foldOp
       value_ = std::intptr_t(ast->foldOp);
@@ -2235,7 +2274,7 @@ void ASTSlot::visit(RightFoldExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2245,7 +2284,7 @@ void ASTSlot::visit(RightFoldExpressionAST* ast) {
     case 2:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 3:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -2255,12 +2294,12 @@ void ASTSlot::visit(RightFoldExpressionAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -2272,7 +2311,7 @@ void ASTSlot::visit(LeftFoldExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -2282,7 +2321,7 @@ void ASTSlot::visit(LeftFoldExpressionAST* ast) {
     case 2:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 3:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2292,12 +2331,12 @@ void ASTSlot::visit(LeftFoldExpressionAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -2309,37 +2348,37 @@ void ASTSlot::visit(RequiresExpressionAST* ast) {
     case 0:  // requiresLoc
       value_ = ast->requiresLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{175};
+      slotNameIndex_ = SlotNameIndex{177};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // parameterDeclarationClause
       value_ = reinterpret_cast<std::intptr_t>(ast->parameterDeclarationClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{156};
+      slotNameIndex_ = SlotNameIndex{158};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 4:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 5:  // requirementList
       value_ = reinterpret_cast<std::intptr_t>(ast->requirementList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{173};
+      slotNameIndex_ = SlotNameIndex{175};
       break;
     case 6:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
   }  // switch
 
@@ -2351,12 +2390,12 @@ void ASTSlot::visit(VaArgExpressionAST* ast) {
     case 0:  // vaArgLoc
       value_ = ast->vaArgLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{226};
+      slotNameIndex_ = SlotNameIndex{228};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2371,12 +2410,12 @@ void ASTSlot::visit(VaArgExpressionAST* ast) {
     case 4:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 5:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2393,17 +2432,17 @@ void ASTSlot::visit(SubscriptExpressionAST* ast) {
     case 1:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 2:  // indexExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->indexExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{105};
+      slotNameIndex_ = SlotNameIndex{107};
       break;
     case 3:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
   }  // switch
 
@@ -2420,7 +2459,7 @@ void ASTSlot::visit(CallExpressionAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -2430,7 +2469,7 @@ void ASTSlot::visit(CallExpressionAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2442,12 +2481,12 @@ void ASTSlot::visit(TypeConstructionAST* ast) {
     case 0:  // typeSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{216};
+      slotNameIndex_ = SlotNameIndex{218};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -2457,7 +2496,7 @@ void ASTSlot::visit(TypeConstructionAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2469,7 +2508,7 @@ void ASTSlot::visit(BracedTypeConstructionAST* ast) {
     case 0:  // typeSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{216};
+      slotNameIndex_ = SlotNameIndex{218};
       break;
     case 1:  // bracedInitList
       value_ = reinterpret_cast<std::intptr_t>(ast->bracedInitList);
@@ -2496,12 +2535,12 @@ void ASTSlot::visit(SpliceMemberExpressionAST* ast) {
     case 2:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 3:  // splicer
       value_ = reinterpret_cast<std::intptr_t>(ast->splicer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{188};
+      slotNameIndex_ = SlotNameIndex{190};
       break;
     case 4:  // accessOp
       value_ = std::intptr_t(ast->accessOp);
@@ -2511,7 +2550,7 @@ void ASTSlot::visit(SpliceMemberExpressionAST* ast) {
     case 5:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -2533,17 +2572,17 @@ void ASTSlot::visit(MemberExpressionAST* ast) {
     case 2:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 3:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // accessOp
       value_ = std::intptr_t(ast->accessOp);
@@ -2553,7 +2592,7 @@ void ASTSlot::visit(MemberExpressionAST* ast) {
     case 6:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -2570,12 +2609,12 @@ void ASTSlot::visit(PostIncrExpressionAST* ast) {
     case 1:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 2:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -2592,22 +2631,22 @@ void ASTSlot::visit(CppCastExpressionAST* ast) {
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 4:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 5:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2617,7 +2656,7 @@ void ASTSlot::visit(CppCastExpressionAST* ast) {
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2634,12 +2673,12 @@ void ASTSlot::visit(BuiltinBitCastExpressionAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // commaLoc
       value_ = ast->commaLoc.index();
@@ -2654,7 +2693,7 @@ void ASTSlot::visit(BuiltinBitCastExpressionAST* ast) {
     case 5:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2666,17 +2705,17 @@ void ASTSlot::visit(BuiltinOffsetofExpressionAST* ast) {
     case 0:  // offsetofLoc
       value_ = ast->offsetofLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{148};
+      slotNameIndex_ = SlotNameIndex{150};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // commaLoc
       value_ = ast->commaLoc.index();
@@ -2691,7 +2730,7 @@ void ASTSlot::visit(BuiltinOffsetofExpressionAST* ast) {
     case 5:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2703,12 +2742,12 @@ void ASTSlot::visit(TypeidExpressionAST* ast) {
     case 0:  // typeidLoc
       value_ = ast->typeidLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{220};
+      slotNameIndex_ = SlotNameIndex{222};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2718,7 +2757,7 @@ void ASTSlot::visit(TypeidExpressionAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2730,22 +2769,22 @@ void ASTSlot::visit(TypeidOfTypeExpressionAST* ast) {
     case 0:  // typeidLoc
       value_ = ast->typeidLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{220};
+      slotNameIndex_ = SlotNameIndex{222};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2757,7 +2796,7 @@ void ASTSlot::visit(SpliceExpressionAST* ast) {
     case 0:  // splicer
       value_ = reinterpret_cast<std::intptr_t>(ast->splicer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{188};
+      slotNameIndex_ = SlotNameIndex{190};
       break;
   }  // switch
 
@@ -2774,7 +2813,7 @@ void ASTSlot::visit(GlobalScopeReflectExpressionAST* ast) {
     case 1:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
   }  // switch
 
@@ -2791,12 +2830,12 @@ void ASTSlot::visit(NamespaceReflectExpressionAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -2813,7 +2852,7 @@ void ASTSlot::visit(TypeIdReflectExpressionAST* ast) {
     case 1:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
   }  // switch
 
@@ -2842,7 +2881,7 @@ void ASTSlot::visit(UnaryExpressionAST* ast) {
     case 0:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2852,7 +2891,7 @@ void ASTSlot::visit(UnaryExpressionAST* ast) {
     case 2:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -2881,7 +2920,7 @@ void ASTSlot::visit(SizeofExpressionAST* ast) {
     case 0:  // sizeofLoc
       value_ = ast->sizeofLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{185};
+      slotNameIndex_ = SlotNameIndex{187};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -2898,22 +2937,22 @@ void ASTSlot::visit(SizeofTypeExpressionAST* ast) {
     case 0:  // sizeofLoc
       value_ = ast->sizeofLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{185};
+      slotNameIndex_ = SlotNameIndex{187};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -2925,7 +2964,7 @@ void ASTSlot::visit(SizeofPackExpressionAST* ast) {
     case 0:  // sizeofLoc
       value_ = ast->sizeofLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{185};
+      slotNameIndex_ = SlotNameIndex{187};
       break;
     case 1:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -2935,22 +2974,22 @@ void ASTSlot::visit(SizeofPackExpressionAST* ast) {
     case 2:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 3:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -2967,17 +3006,17 @@ void ASTSlot::visit(AlignofTypeExpressionAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -3006,12 +3045,12 @@ void ASTSlot::visit(NoexceptExpressionAST* ast) {
     case 0:  // noexceptLoc
       value_ = ast->noexceptLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{146};
+      slotNameIndex_ = SlotNameIndex{148};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3021,7 +3060,7 @@ void ASTSlot::visit(NoexceptExpressionAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -3033,27 +3072,27 @@ void ASTSlot::visit(NewExpressionAST* ast) {
     case 0:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
     case 1:  // newLoc
       value_ = ast->newLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{144};
+      slotNameIndex_ = SlotNameIndex{146};
       break;
     case 2:  // newPlacement
       value_ = reinterpret_cast<std::intptr_t>(ast->newPlacement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{145};
+      slotNameIndex_ = SlotNameIndex{147};
       break;
     case 3:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 4:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 5:  // declarator
       value_ = reinterpret_cast<std::intptr_t>(ast->declarator);
@@ -3063,12 +3102,12 @@ void ASTSlot::visit(NewExpressionAST* ast) {
     case 6:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 7:  // newInitalizer
       value_ = reinterpret_cast<std::intptr_t>(ast->newInitalizer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{143};
+      slotNameIndex_ = SlotNameIndex{145};
       break;
   }  // switch
 
@@ -3080,7 +3119,7 @@ void ASTSlot::visit(DeleteExpressionAST* ast) {
     case 0:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
     case 1:  // deleteLoc
       value_ = ast->deleteLoc.index();
@@ -3090,12 +3129,12 @@ void ASTSlot::visit(DeleteExpressionAST* ast) {
     case 2:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 3:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 4:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3112,17 +3151,17 @@ void ASTSlot::visit(CastExpressionAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 3:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3151,22 +3190,22 @@ void ASTSlot::visit(BinaryExpressionAST* ast) {
     case 0:  // leftExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->leftExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{125};
+      slotNameIndex_ = SlotNameIndex{127};
       break;
     case 1:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 2:  // rightExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->rightExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{178};
+      slotNameIndex_ = SlotNameIndex{180};
       break;
     case 3:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -3183,12 +3222,12 @@ void ASTSlot::visit(ConditionalExpressionAST* ast) {
     case 1:  // questionLoc
       value_ = ast->questionLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{163};
+      slotNameIndex_ = SlotNameIndex{165};
       break;
     case 2:  // iftrueExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->iftrueExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{102};
+      slotNameIndex_ = SlotNameIndex{104};
       break;
     case 3:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -3198,7 +3237,7 @@ void ASTSlot::visit(ConditionalExpressionAST* ast) {
     case 4:  // iffalseExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->iffalseExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{101};
+      slotNameIndex_ = SlotNameIndex{103};
       break;
   }  // switch
 
@@ -3210,7 +3249,7 @@ void ASTSlot::visit(YieldExpressionAST* ast) {
     case 0:  // yieldLoc
       value_ = ast->yieldLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{232};
+      slotNameIndex_ = SlotNameIndex{234};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3227,7 +3266,7 @@ void ASTSlot::visit(ThrowExpressionAST* ast) {
     case 0:  // throwLoc
       value_ = ast->throwLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{207};
+      slotNameIndex_ = SlotNameIndex{209};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3244,22 +3283,22 @@ void ASTSlot::visit(AssignmentExpressionAST* ast) {
     case 0:  // leftExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->leftExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{125};
+      slotNameIndex_ = SlotNameIndex{127};
       break;
     case 1:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 2:  // rightExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->rightExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{178};
+      slotNameIndex_ = SlotNameIndex{180};
       break;
     case 3:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -3293,7 +3332,7 @@ void ASTSlot::visit(DesignatedInitializerClauseAST* ast) {
     case 1:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
   }  // switch
 
@@ -3305,22 +3344,22 @@ void ASTSlot::visit(TypeTraitExpressionAST* ast) {
     case 0:  // typeTraitLoc
       value_ = ast->typeTraitLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{218};
+      slotNameIndex_ = SlotNameIndex{220};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeIdList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeIdList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{213};
+      slotNameIndex_ = SlotNameIndex{215};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -3347,7 +3386,7 @@ void ASTSlot::visit(ConditionExpressionAST* ast) {
     case 3:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
   }  // switch
 
@@ -3376,7 +3415,7 @@ void ASTSlot::visit(BracedInitListAST* ast) {
     case 0:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 1:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -3391,7 +3430,7 @@ void ASTSlot::visit(BracedInitListAST* ast) {
     case 3:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
   }  // switch
 
@@ -3403,7 +3442,7 @@ void ASTSlot::visit(ParenInitializerAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -3413,7 +3452,51 @@ void ASTSlot::visit(ParenInitializerAST* ast) {
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
+      break;
+  }  // switch
+
+  slotCount_ = 3;
+}
+
+void ASTSlot::visit(DefaultGenericAssociationAST* ast) {
+  switch (slot_) {
+    case 0:  // defaultLoc
+      value_ = ast->defaultLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{59};
+      break;
+    case 1:  // colonLoc
+      value_ = ast->colonLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{36};
+      break;
+    case 2:  // expression
+      value_ = reinterpret_cast<std::intptr_t>(ast->expression);
+      slotKind_ = ASTSlotKind::kNode;
+      slotNameIndex_ = SlotNameIndex{78};
+      break;
+  }  // switch
+
+  slotCount_ = 3;
+}
+
+void ASTSlot::visit(TypeGenericAssociationAST* ast) {
+  switch (slot_) {
+    case 0:  // typeId
+      value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
+      slotKind_ = ASTSlotKind::kNode;
+      slotNameIndex_ = SlotNameIndex{214};
+      break;
+    case 1:  // colonLoc
+      value_ = ast->colonLoc.index();
+      slotKind_ = ASTSlotKind::kToken;
+      slotNameIndex_ = SlotNameIndex{36};
+      break;
+    case 2:  // expression
+      value_ = reinterpret_cast<std::intptr_t>(ast->expression);
+      slotKind_ = ASTSlotKind::kNode;
+      slotNameIndex_ = SlotNameIndex{78};
       break;
   }  // switch
 
@@ -3430,12 +3513,12 @@ void ASTSlot::visit(DotDesignatorAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -3447,7 +3530,7 @@ void ASTSlot::visit(SubscriptDesignatorAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3457,7 +3540,7 @@ void ASTSlot::visit(SubscriptDesignatorAST* ast) {
     case 2:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
   }  // switch
 
@@ -3469,7 +3552,7 @@ void ASTSlot::visit(SplicerAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -3489,12 +3572,12 @@ void ASTSlot::visit(SplicerAST* ast) {
     case 4:  // secondColonLoc
       value_ = ast->secondColonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{182};
+      slotNameIndex_ = SlotNameIndex{184};
       break;
     case 5:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
   }  // switch
 
@@ -3506,12 +3589,12 @@ void ASTSlot::visit(GlobalModuleFragmentAST* ast) {
     case 0:  // moduleLoc
       value_ = ast->moduleLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{135};
+      slotNameIndex_ = SlotNameIndex{137};
       break;
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 2:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -3528,7 +3611,7 @@ void ASTSlot::visit(PrivateModuleFragmentAST* ast) {
     case 0:  // moduleLoc
       value_ = ast->moduleLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{135};
+      slotNameIndex_ = SlotNameIndex{137};
       break;
     case 1:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -3538,12 +3621,12 @@ void ASTSlot::visit(PrivateModuleFragmentAST* ast) {
     case 2:  // privateLoc
       value_ = ast->privateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{158};
+      slotNameIndex_ = SlotNameIndex{160};
       break;
     case 3:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 4:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -3565,17 +3648,17 @@ void ASTSlot::visit(ModuleDeclarationAST* ast) {
     case 1:  // moduleLoc
       value_ = ast->moduleLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{135};
+      slotNameIndex_ = SlotNameIndex{137};
       break;
     case 2:  // moduleName
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleName);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{136};
+      slotNameIndex_ = SlotNameIndex{138};
       break;
     case 3:  // modulePartition
       value_ = reinterpret_cast<std::intptr_t>(ast->modulePartition);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{137};
+      slotNameIndex_ = SlotNameIndex{139};
       break;
     case 4:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -3585,7 +3668,7 @@ void ASTSlot::visit(ModuleDeclarationAST* ast) {
     case 5:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -3597,17 +3680,17 @@ void ASTSlot::visit(ModuleNameAST* ast) {
     case 0:  // moduleQualifier
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleQualifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{138};
+      slotNameIndex_ = SlotNameIndex{140};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -3619,12 +3702,12 @@ void ASTSlot::visit(ModuleQualifierAST* ast) {
     case 0:  // moduleQualifier
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleQualifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{138};
+      slotNameIndex_ = SlotNameIndex{140};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // dotLoc
       value_ = ast->dotLoc.index();
@@ -3634,7 +3717,7 @@ void ASTSlot::visit(ModuleQualifierAST* ast) {
     case 3:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -3651,7 +3734,7 @@ void ASTSlot::visit(ModulePartitionAST* ast) {
     case 1:  // moduleName
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleName);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{136};
+      slotNameIndex_ = SlotNameIndex{138};
       break;
   }  // switch
 
@@ -3663,17 +3746,17 @@ void ASTSlot::visit(ImportNameAST* ast) {
     case 0:  // headerLoc
       value_ = ast->headerLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{95};
+      slotNameIndex_ = SlotNameIndex{97};
       break;
     case 1:  // modulePartition
       value_ = reinterpret_cast<std::intptr_t>(ast->modulePartition);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{137};
+      slotNameIndex_ = SlotNameIndex{139};
       break;
     case 2:  // moduleName
       value_ = reinterpret_cast<std::intptr_t>(ast->moduleName);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{136};
+      slotNameIndex_ = SlotNameIndex{138};
       break;
   }  // switch
 
@@ -3690,12 +3773,12 @@ void ASTSlot::visit(InitDeclaratorAST* ast) {
     case 1:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 2:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
   }  // switch
 
@@ -3707,7 +3790,7 @@ void ASTSlot::visit(DeclaratorAST* ast) {
     case 0:  // ptrOpList
       value_ = reinterpret_cast<std::intptr_t>(ast->ptrOpList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{160};
+      slotNameIndex_ = SlotNameIndex{162};
       break;
     case 1:  // coreDeclarator
       value_ = reinterpret_cast<std::intptr_t>(ast->coreDeclarator);
@@ -3729,17 +3812,17 @@ void ASTSlot::visit(UsingDeclaratorAST* ast) {
     case 0:  // typenameLoc
       value_ = ast->typenameLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{221};
+      slotNameIndex_ = SlotNameIndex{223};
       break;
     case 1:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 2:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 3:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -3749,7 +3832,7 @@ void ASTSlot::visit(UsingDeclaratorAST* ast) {
     case 4:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -3761,7 +3844,7 @@ void ASTSlot::visit(EnumeratorAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -3781,7 +3864,7 @@ void ASTSlot::visit(EnumeratorAST* ast) {
     case 4:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -3793,7 +3876,7 @@ void ASTSlot::visit(TypeIdAST* ast) {
     case 0:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 1:  // declarator
       value_ = reinterpret_cast<std::intptr_t>(ast->declarator);
@@ -3815,7 +3898,7 @@ void ASTSlot::visit(HandlerAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // exceptionDeclaration
       value_ = reinterpret_cast<std::intptr_t>(ast->exceptionDeclaration);
@@ -3825,12 +3908,12 @@ void ASTSlot::visit(HandlerAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 4:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -3847,27 +3930,27 @@ void ASTSlot::visit(BaseSpecifierAST* ast) {
     case 1:  // virtualOrAccessLoc
       value_ = ast->virtualOrAccessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{228};
+      slotNameIndex_ = SlotNameIndex{230};
       break;
     case 2:  // otherVirtualOrAccessLoc
       value_ = ast->otherVirtualOrAccessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{154};
+      slotNameIndex_ = SlotNameIndex{156};
       break;
     case 3:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 4:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 5:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 6:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -3877,17 +3960,17 @@ void ASTSlot::visit(BaseSpecifierAST* ast) {
     case 7:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
     case 8:  // isVirtual
       value_ = std::intptr_t(ast->isVirtual != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{120};
+      slotNameIndex_ = SlotNameIndex{122};
       break;
     case 9:  // isVariadic
       value_ = std::intptr_t(ast->isVariadic != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{119};
+      slotNameIndex_ = SlotNameIndex{121};
       break;
     case 10:  // accessSpecifier
       value_ = std::intptr_t(ast->accessSpecifier);
@@ -3904,7 +3987,7 @@ void ASTSlot::visit(RequiresClauseAST* ast) {
     case 0:  // requiresLoc
       value_ = ast->requiresLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{175};
+      slotNameIndex_ = SlotNameIndex{177};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -3921,7 +4004,7 @@ void ASTSlot::visit(ParameterDeclarationClauseAST* ast) {
     case 0:  // parameterDeclarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->parameterDeclarationList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{157};
+      slotNameIndex_ = SlotNameIndex{159};
       break;
     case 1:  // commaLoc
       value_ = ast->commaLoc.index();
@@ -3936,7 +4019,7 @@ void ASTSlot::visit(ParameterDeclarationClauseAST* ast) {
     case 3:  // isVariadic
       value_ = std::intptr_t(ast->isVariadic != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{119};
+      slotNameIndex_ = SlotNameIndex{121};
       break;
   }  // switch
 
@@ -3948,12 +4031,12 @@ void ASTSlot::visit(TrailingReturnTypeAST* ast) {
     case 0:  // minusGreaterLoc
       value_ = ast->minusGreaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{133};
+      slotNameIndex_ = SlotNameIndex{135};
       break;
     case 1:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
   }  // switch
 
@@ -3965,12 +4048,12 @@ void ASTSlot::visit(LambdaSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -3982,32 +4065,32 @@ void ASTSlot::visit(TypeConstraintAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 3:  // templateArgumentList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateArgumentList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{199};
+      slotNameIndex_ = SlotNameIndex{201};
       break;
     case 4:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 5:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -4019,12 +4102,12 @@ void ASTSlot::visit(AttributeArgumentClauseAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4058,7 +4141,7 @@ void ASTSlot::visit(AttributeUsingPrefixAST* ast) {
     case 0:  // usingLoc
       value_ = ast->usingLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{225};
+      slotNameIndex_ = SlotNameIndex{227};
       break;
     case 1:  // attributeNamespaceLoc
       value_ = ast->attributeNamespaceLoc.index();
@@ -4080,7 +4163,7 @@ void ASTSlot::visit(NewPlacementAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -4090,7 +4173,7 @@ void ASTSlot::visit(NewPlacementAST* ast) {
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4102,27 +4185,27 @@ void ASTSlot::visit(NestedNamespaceSpecifierAST* ast) {
     case 0:  // inlineLoc
       value_ = ast->inlineLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{108};
+      slotNameIndex_ = SlotNameIndex{110};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
     case 3:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 4:  // isInline
       value_ = std::intptr_t(ast->isInline != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{111};
+      slotNameIndex_ = SlotNameIndex{113};
       break;
   }  // switch
 
@@ -4134,27 +4217,27 @@ void ASTSlot::visit(TemplateTypeParameterAST* ast) {
     case 0:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // templateParameterList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateParameterList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{202};
+      slotNameIndex_ = SlotNameIndex{204};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 4:  // requiresClause
       value_ = reinterpret_cast<std::intptr_t>(ast->requiresClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{174};
+      slotNameIndex_ = SlotNameIndex{176};
       break;
     case 5:  // classKeyLoc
       value_ = ast->classKeyLoc.index();
@@ -4169,7 +4252,7 @@ void ASTSlot::visit(TemplateTypeParameterAST* ast) {
     case 7:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 8:  // equalLoc
       value_ = ast->equalLoc.index();
@@ -4179,17 +4262,17 @@ void ASTSlot::visit(TemplateTypeParameterAST* ast) {
     case 9:  // idExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->idExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{97};
+      slotNameIndex_ = SlotNameIndex{99};
       break;
     case 10:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 11:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -4223,7 +4306,7 @@ void ASTSlot::visit(TypenameTypeParameterAST* ast) {
     case 2:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 3:  // equalLoc
       value_ = ast->equalLoc.index();
@@ -4233,17 +4316,17 @@ void ASTSlot::visit(TypenameTypeParameterAST* ast) {
     case 4:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 5:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 6:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -4255,7 +4338,7 @@ void ASTSlot::visit(ConstraintTypeParameterAST* ast) {
     case 0:  // typeConstraint
       value_ = reinterpret_cast<std::intptr_t>(ast->typeConstraint);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{211};
+      slotNameIndex_ = SlotNameIndex{213};
       break;
     case 1:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -4265,7 +4348,7 @@ void ASTSlot::visit(ConstraintTypeParameterAST* ast) {
     case 2:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 3:  // equalLoc
       value_ = ast->equalLoc.index();
@@ -4275,12 +4358,12 @@ void ASTSlot::visit(ConstraintTypeParameterAST* ast) {
     case 4:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 5:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -4292,7 +4375,7 @@ void ASTSlot::visit(GeneratedTypeSpecifierAST* ast) {
     case 0:  // typeLoc
       value_ = ast->typeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{214};
+      slotNameIndex_ = SlotNameIndex{216};
       break;
   }  // switch
 
@@ -4304,7 +4387,7 @@ void ASTSlot::visit(TypedefSpecifierAST* ast) {
     case 0:  // typedefLoc
       value_ = ast->typedefLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{219};
+      slotNameIndex_ = SlotNameIndex{221};
       break;
   }  // switch
 
@@ -4364,7 +4447,7 @@ void ASTSlot::visit(InlineSpecifierAST* ast) {
     case 0:  // inlineLoc
       value_ = ast->inlineLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{108};
+      slotNameIndex_ = SlotNameIndex{110};
       break;
   }  // switch
 
@@ -4376,7 +4459,7 @@ void ASTSlot::visit(NoreturnSpecifierAST* ast) {
     case 0:  // noreturnLoc
       value_ = ast->noreturnLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{147};
+      slotNameIndex_ = SlotNameIndex{149};
       break;
   }  // switch
 
@@ -4388,7 +4471,7 @@ void ASTSlot::visit(StaticSpecifierAST* ast) {
     case 0:  // staticLoc
       value_ = ast->staticLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{193};
+      slotNameIndex_ = SlotNameIndex{195};
       break;
   }  // switch
 
@@ -4412,7 +4495,7 @@ void ASTSlot::visit(RegisterSpecifierAST* ast) {
     case 0:  // registerLoc
       value_ = ast->registerLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{172};
+      slotNameIndex_ = SlotNameIndex{174};
       break;
   }  // switch
 
@@ -4424,7 +4507,7 @@ void ASTSlot::visit(ThreadLocalSpecifierAST* ast) {
     case 0:  // threadLocalLoc
       value_ = ast->threadLocalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{206};
+      slotNameIndex_ = SlotNameIndex{208};
       break;
   }  // switch
 
@@ -4436,7 +4519,7 @@ void ASTSlot::visit(ThreadSpecifierAST* ast) {
     case 0:  // threadLoc
       value_ = ast->threadLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{205};
+      slotNameIndex_ = SlotNameIndex{207};
       break;
   }  // switch
 
@@ -4448,7 +4531,7 @@ void ASTSlot::visit(MutableSpecifierAST* ast) {
     case 0:  // mutableLoc
       value_ = ast->mutableLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{139};
+      slotNameIndex_ = SlotNameIndex{141};
       break;
   }  // switch
 
@@ -4460,7 +4543,7 @@ void ASTSlot::visit(VirtualSpecifierAST* ast) {
     case 0:  // virtualLoc
       value_ = ast->virtualLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{227};
+      slotNameIndex_ = SlotNameIndex{229};
       break;
   }  // switch
 
@@ -4477,7 +4560,7 @@ void ASTSlot::visit(ExplicitSpecifierAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -4487,7 +4570,7 @@ void ASTSlot::visit(ExplicitSpecifierAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4511,7 +4594,7 @@ void ASTSlot::visit(VoidTypeSpecifierAST* ast) {
     case 0:  // voidLoc
       value_ = ast->voidLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{229};
+      slotNameIndex_ = SlotNameIndex{231};
       break;
   }  // switch
 
@@ -4523,12 +4606,12 @@ void ASTSlot::visit(SizeTypeSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4540,12 +4623,12 @@ void ASTSlot::visit(SignTypeSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4557,12 +4640,12 @@ void ASTSlot::visit(VaListTypeSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4574,12 +4657,12 @@ void ASTSlot::visit(IntegralTypeSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4591,12 +4674,12 @@ void ASTSlot::visit(FloatingPointTypeSpecifierAST* ast) {
     case 0:  // specifierLoc
       value_ = ast->specifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{187};
+      slotNameIndex_ = SlotNameIndex{189};
       break;
     case 1:  // specifier
       value_ = std::intptr_t(ast->specifier);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4620,22 +4703,22 @@ void ASTSlot::visit(NamedTypeSpecifierAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 2:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 3:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -4652,17 +4735,17 @@ void ASTSlot::visit(AtomicTypeSpecifierAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4674,22 +4757,22 @@ void ASTSlot::visit(UnderlyingTypeSpecifierAST* ast) {
     case 0:  // underlyingTypeLoc
       value_ = ast->underlyingTypeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{222};
+      slotNameIndex_ = SlotNameIndex{224};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4711,17 +4794,17 @@ void ASTSlot::visit(ElaboratedTypeSpecifierAST* ast) {
     case 2:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 3:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // classKey
       value_ = std::intptr_t(ast->classKey);
@@ -4731,7 +4814,7 @@ void ASTSlot::visit(ElaboratedTypeSpecifierAST* ast) {
     case 6:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -4748,7 +4831,7 @@ void ASTSlot::visit(DecltypeAutoSpecifierAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // autoLoc
       value_ = ast->autoLoc.index();
@@ -4758,7 +4841,7 @@ void ASTSlot::visit(DecltypeAutoSpecifierAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4775,7 +4858,7 @@ void ASTSlot::visit(DecltypeSpecifierAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -4785,7 +4868,7 @@ void ASTSlot::visit(DecltypeSpecifierAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -4797,12 +4880,12 @@ void ASTSlot::visit(PlaceholderTypeSpecifierAST* ast) {
     case 0:  // typeConstraint
       value_ = reinterpret_cast<std::intptr_t>(ast->typeConstraint);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{211};
+      slotNameIndex_ = SlotNameIndex{213};
       break;
     case 1:  // specifier
       value_ = reinterpret_cast<std::intptr_t>(ast->specifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{186};
+      slotNameIndex_ = SlotNameIndex{188};
       break;
   }  // switch
 
@@ -4826,7 +4909,7 @@ void ASTSlot::visit(VolatileQualifierAST* ast) {
     case 0:  // volatileLoc
       value_ = ast->volatileLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{230};
+      slotNameIndex_ = SlotNameIndex{232};
       break;
   }  // switch
 
@@ -4850,7 +4933,7 @@ void ASTSlot::visit(RestrictQualifierAST* ast) {
     case 0:  // restrictLoc
       value_ = ast->restrictLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{176};
+      slotNameIndex_ = SlotNameIndex{178};
       break;
   }  // switch
 
@@ -4877,12 +4960,12 @@ void ASTSlot::visit(EnumSpecifierAST* ast) {
     case 3:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 4:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 5:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -4892,12 +4975,12 @@ void ASTSlot::visit(EnumSpecifierAST* ast) {
     case 6:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 7:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 8:  // enumeratorList
       value_ = reinterpret_cast<std::intptr_t>(ast->enumeratorList);
@@ -4912,7 +4995,7 @@ void ASTSlot::visit(EnumSpecifierAST* ast) {
     case 10:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
   }  // switch
 
@@ -4934,12 +5017,12 @@ void ASTSlot::visit(ClassSpecifierAST* ast) {
     case 2:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 3:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 4:  // finalLoc
       value_ = ast->finalLoc.index();
@@ -4959,7 +5042,7 @@ void ASTSlot::visit(ClassSpecifierAST* ast) {
     case 7:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 8:  // declarationList
       value_ = reinterpret_cast<std::intptr_t>(ast->declarationList);
@@ -4969,7 +5052,7 @@ void ASTSlot::visit(ClassSpecifierAST* ast) {
     case 9:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
     case 10:  // classKey
       value_ = std::intptr_t(ast->classKey);
@@ -4979,7 +5062,7 @@ void ASTSlot::visit(ClassSpecifierAST* ast) {
     case 11:  // isFinal
       value_ = std::intptr_t(ast->isFinal != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{110};
+      slotNameIndex_ = SlotNameIndex{112};
       break;
   }  // switch
 
@@ -4991,27 +5074,27 @@ void ASTSlot::visit(TypenameSpecifierAST* ast) {
     case 0:  // typenameLoc
       value_ = ast->typenameLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{221};
+      slotNameIndex_ = SlotNameIndex{223};
       break;
     case 1:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 2:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 3:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 4:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -5023,12 +5106,12 @@ void ASTSlot::visit(SplicerTypeSpecifierAST* ast) {
     case 0:  // typenameLoc
       value_ = ast->typenameLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{221};
+      slotNameIndex_ = SlotNameIndex{223};
       break;
     case 1:  // splicer
       value_ = reinterpret_cast<std::intptr_t>(ast->splicer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{188};
+      slotNameIndex_ = SlotNameIndex{190};
       break;
   }  // switch
 
@@ -5040,7 +5123,7 @@ void ASTSlot::visit(PointerOperatorAST* ast) {
     case 0:  // starLoc
       value_ = ast->starLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{189};
+      slotNameIndex_ = SlotNameIndex{191};
       break;
     case 1:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -5062,7 +5145,7 @@ void ASTSlot::visit(ReferenceOperatorAST* ast) {
     case 0:  // refLoc
       value_ = ast->refLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{169};
+      slotNameIndex_ = SlotNameIndex{171};
       break;
     case 1:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -5072,7 +5155,7 @@ void ASTSlot::visit(ReferenceOperatorAST* ast) {
     case 2:  // refOp
       value_ = std::intptr_t(ast->refOp);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{170};
+      slotNameIndex_ = SlotNameIndex{172};
       break;
   }  // switch
 
@@ -5084,12 +5167,12 @@ void ASTSlot::visit(PtrToMemberOperatorAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // starLoc
       value_ = ast->starLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{189};
+      slotNameIndex_ = SlotNameIndex{191};
       break;
     case 2:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -5111,7 +5194,7 @@ void ASTSlot::visit(BitfieldDeclaratorAST* ast) {
     case 0:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 1:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -5121,7 +5204,7 @@ void ASTSlot::visit(BitfieldDeclaratorAST* ast) {
     case 2:  // sizeExpression
       value_ = reinterpret_cast<std::intptr_t>(ast->sizeExpression);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{184};
+      slotNameIndex_ = SlotNameIndex{186};
       break;
   }  // switch
 
@@ -5150,17 +5233,17 @@ void ASTSlot::visit(IdDeclaratorAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 2:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 3:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -5170,7 +5253,7 @@ void ASTSlot::visit(IdDeclaratorAST* ast) {
     case 4:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -5182,7 +5265,7 @@ void ASTSlot::visit(NestedDeclaratorAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // declarator
       value_ = reinterpret_cast<std::intptr_t>(ast->declarator);
@@ -5192,7 +5275,7 @@ void ASTSlot::visit(NestedDeclaratorAST* ast) {
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -5204,17 +5287,17 @@ void ASTSlot::visit(FunctionDeclaratorChunkAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // parameterDeclarationClause
       value_ = reinterpret_cast<std::intptr_t>(ast->parameterDeclarationClause);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{156};
+      slotNameIndex_ = SlotNameIndex{158};
       break;
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 3:  // cvQualifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->cvQualifierList);
@@ -5224,7 +5307,7 @@ void ASTSlot::visit(FunctionDeclaratorChunkAST* ast) {
     case 4:  // refLoc
       value_ = ast->refLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{169};
+      slotNameIndex_ = SlotNameIndex{171};
       break;
     case 5:  // exceptionSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->exceptionSpecifier);
@@ -5239,22 +5322,22 @@ void ASTSlot::visit(FunctionDeclaratorChunkAST* ast) {
     case 7:  // trailingReturnType
       value_ = reinterpret_cast<std::intptr_t>(ast->trailingReturnType);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{209};
+      slotNameIndex_ = SlotNameIndex{211};
       break;
     case 8:  // isFinal
       value_ = std::intptr_t(ast->isFinal != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{110};
+      slotNameIndex_ = SlotNameIndex{112};
       break;
     case 9:  // isOverride
       value_ = std::intptr_t(ast->isOverride != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{113};
+      slotNameIndex_ = SlotNameIndex{115};
       break;
     case 10:  // isPure
       value_ = std::intptr_t(ast->isPure != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{115};
+      slotNameIndex_ = SlotNameIndex{117};
       break;
   }  // switch
 
@@ -5266,12 +5349,12 @@ void ASTSlot::visit(ArrayDeclaratorChunkAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // typeQualifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeQualifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{215};
+      slotNameIndex_ = SlotNameIndex{217};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -5281,7 +5364,7 @@ void ASTSlot::visit(ArrayDeclaratorChunkAST* ast) {
     case 3:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 4:  // attributeList
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeList);
@@ -5298,12 +5381,12 @@ void ASTSlot::visit(NameIdAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -5315,12 +5398,12 @@ void ASTSlot::visit(DestructorIdAST* ast) {
     case 0:  // tildeLoc
       value_ = ast->tildeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{208};
+      slotNameIndex_ = SlotNameIndex{210};
       break;
     case 1:  // id
       value_ = reinterpret_cast<std::intptr_t>(ast->id);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{96};
+      slotNameIndex_ = SlotNameIndex{98};
       break;
   }  // switch
 
@@ -5344,17 +5427,17 @@ void ASTSlot::visit(OperatorFunctionIdAST* ast) {
     case 0:  // operatorLoc
       value_ = ast->operatorLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{153};
+      slotNameIndex_ = SlotNameIndex{155};
       break;
     case 1:  // opLoc
       value_ = ast->opLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{150};
+      slotNameIndex_ = SlotNameIndex{152};
       break;
     case 2:  // openLoc
       value_ = ast->openLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{151};
+      slotNameIndex_ = SlotNameIndex{153};
       break;
     case 3:  // closeLoc
       value_ = ast->closeLoc.index();
@@ -5364,7 +5447,7 @@ void ASTSlot::visit(OperatorFunctionIdAST* ast) {
     case 4:  // op
       value_ = std::intptr_t(ast->op);
       slotKind_ = ASTSlotKind::kIntAttribute;
-      slotNameIndex_ = SlotNameIndex{149};
+      slotNameIndex_ = SlotNameIndex{151};
       break;
   }  // switch
 
@@ -5376,27 +5459,27 @@ void ASTSlot::visit(LiteralOperatorIdAST* ast) {
     case 0:  // operatorLoc
       value_ = ast->operatorLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{153};
+      slotNameIndex_ = SlotNameIndex{155};
       break;
     case 1:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 2:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 3:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
     case 4:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -5408,12 +5491,12 @@ void ASTSlot::visit(ConversionFunctionIdAST* ast) {
     case 0:  // operatorLoc
       value_ = ast->operatorLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{153};
+      slotNameIndex_ = SlotNameIndex{155};
       break;
     case 1:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
   }  // switch
 
@@ -5425,27 +5508,27 @@ void ASTSlot::visit(SimpleTemplateIdAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // templateArgumentList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateArgumentList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{199};
+      slotNameIndex_ = SlotNameIndex{201};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
     case 4:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -5457,22 +5540,22 @@ void ASTSlot::visit(LiteralOperatorTemplateIdAST* ast) {
     case 0:  // literalOperatorId
       value_ = reinterpret_cast<std::intptr_t>(ast->literalOperatorId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{129};
+      slotNameIndex_ = SlotNameIndex{131};
       break;
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // templateArgumentList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateArgumentList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{199};
+      slotNameIndex_ = SlotNameIndex{201};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
   }  // switch
 
@@ -5484,22 +5567,22 @@ void ASTSlot::visit(OperatorFunctionTemplateIdAST* ast) {
     case 0:  // operatorFunctionId
       value_ = reinterpret_cast<std::intptr_t>(ast->operatorFunctionId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{152};
+      slotNameIndex_ = SlotNameIndex{154};
       break;
     case 1:  // lessLoc
       value_ = ast->lessLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{126};
+      slotNameIndex_ = SlotNameIndex{128};
       break;
     case 2:  // templateArgumentList
       value_ = reinterpret_cast<std::intptr_t>(ast->templateArgumentList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{199};
+      slotNameIndex_ = SlotNameIndex{201};
       break;
     case 3:  // greaterLoc
       value_ = ast->greaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{93};
+      slotNameIndex_ = SlotNameIndex{95};
       break;
   }  // switch
 
@@ -5511,7 +5594,7 @@ void ASTSlot::visit(GlobalNestedNameSpecifierAST* ast) {
     case 0:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
   }  // switch
 
@@ -5523,22 +5606,22 @@ void ASTSlot::visit(SimpleNestedNameSpecifierAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
     case 3:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
   }  // switch
 
@@ -5555,7 +5638,7 @@ void ASTSlot::visit(DecltypeNestedNameSpecifierAST* ast) {
     case 1:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
   }  // switch
 
@@ -5567,27 +5650,27 @@ void ASTSlot::visit(TemplateNestedNameSpecifierAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 2:  // templateId
       value_ = reinterpret_cast<std::intptr_t>(ast->templateId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{200};
+      slotNameIndex_ = SlotNameIndex{202};
       break;
     case 3:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
     case 4:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -5609,7 +5692,7 @@ void ASTSlot::visit(DefaultFunctionBodyAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -5626,12 +5709,12 @@ void ASTSlot::visit(CompoundStatementFunctionBodyAST* ast) {
     case 1:  // memInitializerList
       value_ = reinterpret_cast<std::intptr_t>(ast->memInitializerList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{132};
+      slotNameIndex_ = SlotNameIndex{134};
       break;
     case 2:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
   }  // switch
 
@@ -5643,7 +5726,7 @@ void ASTSlot::visit(TryStatementFunctionBodyAST* ast) {
     case 0:  // tryLoc
       value_ = ast->tryLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{210};
+      slotNameIndex_ = SlotNameIndex{212};
       break;
     case 1:  // colonLoc
       value_ = ast->colonLoc.index();
@@ -5653,17 +5736,17 @@ void ASTSlot::visit(TryStatementFunctionBodyAST* ast) {
     case 2:  // memInitializerList
       value_ = reinterpret_cast<std::intptr_t>(ast->memInitializerList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{132};
+      slotNameIndex_ = SlotNameIndex{134};
       break;
     case 3:  // statement
       value_ = reinterpret_cast<std::intptr_t>(ast->statement);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{190};
+      slotNameIndex_ = SlotNameIndex{192};
       break;
     case 4:  // handlerList
       value_ = reinterpret_cast<std::intptr_t>(ast->handlerList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{94};
+      slotNameIndex_ = SlotNameIndex{96};
       break;
   }  // switch
 
@@ -5685,7 +5768,7 @@ void ASTSlot::visit(DeleteFunctionBodyAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -5697,7 +5780,7 @@ void ASTSlot::visit(TypeTemplateArgumentAST* ast) {
     case 0:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
   }  // switch
 
@@ -5721,17 +5804,17 @@ void ASTSlot::visit(ThrowExceptionSpecifierAST* ast) {
     case 0:  // throwLoc
       value_ = ast->throwLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{207};
+      slotNameIndex_ = SlotNameIndex{209};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -5743,12 +5826,12 @@ void ASTSlot::visit(NoexceptSpecifierAST* ast) {
     case 0:  // noexceptLoc
       value_ = ast->noexceptLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{146};
+      slotNameIndex_ = SlotNameIndex{148};
       break;
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -5758,7 +5841,7 @@ void ASTSlot::visit(NoexceptSpecifierAST* ast) {
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -5775,7 +5858,7 @@ void ASTSlot::visit(SimpleRequirementAST* ast) {
     case 1:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -5787,7 +5870,7 @@ void ASTSlot::visit(CompoundRequirementAST* ast) {
     case 0:  // lbraceLoc
       value_ = ast->lbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{122};
+      slotNameIndex_ = SlotNameIndex{124};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -5797,27 +5880,27 @@ void ASTSlot::visit(CompoundRequirementAST* ast) {
     case 2:  // rbraceLoc
       value_ = ast->rbraceLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{166};
+      slotNameIndex_ = SlotNameIndex{168};
       break;
     case 3:  // noexceptLoc
       value_ = ast->noexceptLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{146};
+      slotNameIndex_ = SlotNameIndex{148};
       break;
     case 4:  // minusGreaterLoc
       value_ = ast->minusGreaterLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{133};
+      slotNameIndex_ = SlotNameIndex{135};
       break;
     case 5:  // typeConstraint
       value_ = reinterpret_cast<std::intptr_t>(ast->typeConstraint);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{211};
+      slotNameIndex_ = SlotNameIndex{213};
       break;
     case 6:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -5829,32 +5912,32 @@ void ASTSlot::visit(TypeRequirementAST* ast) {
     case 0:  // typenameLoc
       value_ = ast->typenameLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{221};
+      slotNameIndex_ = SlotNameIndex{223};
       break;
     case 1:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 2:  // templateLoc
       value_ = ast->templateLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{201};
+      slotNameIndex_ = SlotNameIndex{203};
       break;
     case 3:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 4:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
     case 5:  // isTemplateIntroduced
       value_ = std::intptr_t(ast->isTemplateIntroduced != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{116};
+      slotNameIndex_ = SlotNameIndex{118};
       break;
   }  // switch
 
@@ -5866,7 +5949,7 @@ void ASTSlot::visit(NestedRequirementAST* ast) {
     case 0:  // requiresLoc
       value_ = ast->requiresLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{175};
+      slotNameIndex_ = SlotNameIndex{177};
       break;
     case 1:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -5876,7 +5959,7 @@ void ASTSlot::visit(NestedRequirementAST* ast) {
     case 2:  // semicolonLoc
       value_ = ast->semicolonLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{183};
+      slotNameIndex_ = SlotNameIndex{185};
       break;
   }  // switch
 
@@ -5888,7 +5971,7 @@ void ASTSlot::visit(NewParenInitializerAST* ast) {
     case 0:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 1:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -5898,7 +5981,7 @@ void ASTSlot::visit(NewParenInitializerAST* ast) {
     case 2:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
   }  // switch
 
@@ -5922,17 +6005,17 @@ void ASTSlot::visit(ParenMemInitializerAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 2:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 3:  // expressionList
       value_ = reinterpret_cast<std::intptr_t>(ast->expressionList);
@@ -5942,7 +6025,7 @@ void ASTSlot::visit(ParenMemInitializerAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -5959,12 +6042,12 @@ void ASTSlot::visit(BracedMemInitializerAST* ast) {
     case 0:  // nestedNameSpecifier
       value_ = reinterpret_cast<std::intptr_t>(ast->nestedNameSpecifier);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{141};
+      slotNameIndex_ = SlotNameIndex{143};
       break;
     case 1:  // unqualifiedId
       value_ = reinterpret_cast<std::intptr_t>(ast->unqualifiedId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{223};
+      slotNameIndex_ = SlotNameIndex{225};
       break;
     case 2:  // bracedInitList
       value_ = reinterpret_cast<std::intptr_t>(ast->bracedInitList);
@@ -5986,7 +6069,7 @@ void ASTSlot::visit(ThisLambdaCaptureAST* ast) {
     case 0:  // thisLoc
       value_ = ast->thisLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{204};
+      slotNameIndex_ = SlotNameIndex{206};
       break;
   }  // switch
 
@@ -5998,12 +6081,12 @@ void ASTSlot::visit(DerefThisLambdaCaptureAST* ast) {
     case 0:  // starLoc
       value_ = ast->starLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{189};
+      slotNameIndex_ = SlotNameIndex{191};
       break;
     case 1:  // thisLoc
       value_ = ast->thisLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{204};
+      slotNameIndex_ = SlotNameIndex{206};
       break;
   }  // switch
 
@@ -6015,7 +6098,7 @@ void ASTSlot::visit(SimpleLambdaCaptureAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -6025,7 +6108,7 @@ void ASTSlot::visit(SimpleLambdaCaptureAST* ast) {
     case 2:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -6042,7 +6125,7 @@ void ASTSlot::visit(RefLambdaCaptureAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -6052,7 +6135,7 @@ void ASTSlot::visit(RefLambdaCaptureAST* ast) {
     case 3:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -6074,17 +6157,17 @@ void ASTSlot::visit(RefInitLambdaCaptureAST* ast) {
     case 2:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 3:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 4:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -6101,17 +6184,17 @@ void ASTSlot::visit(InitLambdaCaptureAST* ast) {
     case 1:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 2:  // initializer
       value_ = reinterpret_cast<std::intptr_t>(ast->initializer);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{107};
+      slotNameIndex_ = SlotNameIndex{109};
       break;
     case 3:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -6140,7 +6223,7 @@ void ASTSlot::visit(TypeExceptionDeclarationAST* ast) {
     case 1:  // typeSpecifierList
       value_ = reinterpret_cast<std::intptr_t>(ast->typeSpecifierList);
       slotKind_ = ASTSlotKind::kNodeList;
-      slotNameIndex_ = SlotNameIndex{217};
+      slotNameIndex_ = SlotNameIndex{219};
       break;
     case 2:  // declarator
       value_ = reinterpret_cast<std::intptr_t>(ast->declarator);
@@ -6157,12 +6240,12 @@ void ASTSlot::visit(CxxAttributeAST* ast) {
     case 0:  // lbracketLoc
       value_ = ast->lbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{124};
+      slotNameIndex_ = SlotNameIndex{126};
       break;
     case 1:  // lbracket2Loc
       value_ = ast->lbracket2Loc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{123};
+      slotNameIndex_ = SlotNameIndex{125};
       break;
     case 2:  // attributeUsingPrefix
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeUsingPrefix);
@@ -6177,12 +6260,12 @@ void ASTSlot::visit(CxxAttributeAST* ast) {
     case 4:  // rbracketLoc
       value_ = ast->rbracketLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{168};
+      slotNameIndex_ = SlotNameIndex{170};
       break;
     case 5:  // rbracket2Loc
       value_ = ast->rbracket2Loc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{167};
+      slotNameIndex_ = SlotNameIndex{169};
       break;
   }  // switch
 
@@ -6199,22 +6282,22 @@ void ASTSlot::visit(GccAttributeAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // lparen2Loc
       value_ = ast->lparen2Loc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{130};
+      slotNameIndex_ = SlotNameIndex{132};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 4:  // rparen2Loc
       value_ = ast->rparen2Loc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{179};
+      slotNameIndex_ = SlotNameIndex{181};
       break;
   }  // switch
 
@@ -6231,7 +6314,7 @@ void ASTSlot::visit(AlignasAttributeAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // expression
       value_ = reinterpret_cast<std::intptr_t>(ast->expression);
@@ -6246,12 +6329,12 @@ void ASTSlot::visit(AlignasAttributeAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -6268,12 +6351,12 @@ void ASTSlot::visit(AlignasTypeAttributeAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // typeId
       value_ = reinterpret_cast<std::intptr_t>(ast->typeId);
       slotKind_ = ASTSlotKind::kNode;
-      slotNameIndex_ = SlotNameIndex{212};
+      slotNameIndex_ = SlotNameIndex{214};
       break;
     case 3:  // ellipsisLoc
       value_ = ast->ellipsisLoc.index();
@@ -6283,12 +6366,12 @@ void ASTSlot::visit(AlignasTypeAttributeAST* ast) {
     case 4:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 5:  // isPack
       value_ = std::intptr_t(ast->isPack != 0);
       slotKind_ = ASTSlotKind::kBoolAttribute;
-      slotNameIndex_ = SlotNameIndex{114};
+      slotNameIndex_ = SlotNameIndex{116};
       break;
   }  // switch
 
@@ -6305,22 +6388,22 @@ void ASTSlot::visit(AsmAttributeAST* ast) {
     case 1:  // lparenLoc
       value_ = ast->lparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{131};
+      slotNameIndex_ = SlotNameIndex{133};
       break;
     case 2:  // literalLoc
       value_ = ast->literalLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{128};
+      slotNameIndex_ = SlotNameIndex{130};
       break;
     case 3:  // rparenLoc
       value_ = ast->rparenLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{180};
+      slotNameIndex_ = SlotNameIndex{182};
       break;
     case 4:  // literal
       value_ = reinterpret_cast<std::intptr_t>(ast->literal);
       slotKind_ = ASTSlotKind::kLiteralAttribute;
-      slotNameIndex_ = SlotNameIndex{127};
+      slotNameIndex_ = SlotNameIndex{129};
       break;
   }  // switch
 
@@ -6337,12 +6420,12 @@ void ASTSlot::visit(ScopedAttributeTokenAST* ast) {
     case 1:  // scopeLoc
       value_ = ast->scopeLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{181};
+      slotNameIndex_ = SlotNameIndex{183};
       break;
     case 2:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 3:  // attributeNamespace
       value_ = reinterpret_cast<std::intptr_t>(ast->attributeNamespace);
@@ -6352,7 +6435,7 @@ void ASTSlot::visit(ScopedAttributeTokenAST* ast) {
     case 4:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
@@ -6364,12 +6447,12 @@ void ASTSlot::visit(SimpleAttributeTokenAST* ast) {
     case 0:  // identifierLoc
       value_ = ast->identifierLoc.index();
       slotKind_ = ASTSlotKind::kToken;
-      slotNameIndex_ = SlotNameIndex{99};
+      slotNameIndex_ = SlotNameIndex{101};
       break;
     case 1:  // identifier
       value_ = reinterpret_cast<std::intptr_t>(ast->identifier);
       slotKind_ = ASTSlotKind::kIdentifierAttribute;
-      slotNameIndex_ = SlotNameIndex{98};
+      slotNameIndex_ = SlotNameIndex{100};
       break;
   }  // switch
 
diff --git a/src/parser/cxx/ast_slot.h b/src/parser/cxx/ast_slot.h
index 86d14bd6..42f48d55 100644
--- a/src/parser/cxx/ast_slot.h
+++ b/src/parser/cxx/ast_slot.h
@@ -117,6 +117,7 @@ class ASTSlot final : ASTVisitor {
   void visit(UserDefinedStringLiteralExpressionAST* ast) override;
   void visit(ObjectLiteralExpressionAST* ast) override;
   void visit(ThisExpressionAST* ast) override;
+  void visit(GenericSelectionExpressionAST* ast) override;
   void visit(NestedStatementExpressionAST* ast) override;
   void visit(NestedExpressionAST* ast) override;
   void visit(IdExpressionAST* ast) override;
@@ -168,6 +169,9 @@ class ASTSlot final : ASTVisitor {
   void visit(BracedInitListAST* ast) override;
   void visit(ParenInitializerAST* ast) override;
 
+  void visit(DefaultGenericAssociationAST* ast) override;
+  void visit(TypeGenericAssociationAST* ast) override;
+
   void visit(DotDesignatorAST* ast) override;
   void visit(SubscriptDesignatorAST* ast) override;
 
diff --git a/src/parser/cxx/ast_visitor.cc b/src/parser/cxx/ast_visitor.cc
index 9a965ee9..c055061f 100644
--- a/src/parser/cxx/ast_visitor.cc
+++ b/src/parser/cxx/ast_visitor.cc
@@ -347,6 +347,13 @@ void ASTVisitor::visit(ObjectLiteralExpressionAST* ast) {
 
 void ASTVisitor::visit(ThisExpressionAST* ast) {}
 
+void ASTVisitor::visit(GenericSelectionExpressionAST* ast) {
+  accept(ast->expression);
+  for (auto node : ListView{ast->genericAssociationList}) {
+    accept(node);
+  }
+}
+
 void ASTVisitor::visit(NestedStatementExpressionAST* ast) {
   accept(ast->statement);
 }
@@ -569,6 +576,15 @@ void ASTVisitor::visit(ParenInitializerAST* ast) {
   }
 }
 
+void ASTVisitor::visit(DefaultGenericAssociationAST* ast) {
+  accept(ast->expression);
+}
+
+void ASTVisitor::visit(TypeGenericAssociationAST* ast) {
+  accept(ast->typeId);
+  accept(ast->expression);
+}
+
 void ASTVisitor::visit(DotDesignatorAST* ast) {}
 
 void ASTVisitor::visit(SubscriptDesignatorAST* ast) { accept(ast->expression); }
diff --git a/src/parser/cxx/ast_visitor.h b/src/parser/cxx/ast_visitor.h
index e56b1007..065f51f2 100644
--- a/src/parser/cxx/ast_visitor.h
+++ b/src/parser/cxx/ast_visitor.h
@@ -101,6 +101,7 @@ class ASTVisitor {
   virtual void visit(UserDefinedStringLiteralExpressionAST* ast);
   virtual void visit(ObjectLiteralExpressionAST* ast);
   virtual void visit(ThisExpressionAST* ast);
+  virtual void visit(GenericSelectionExpressionAST* ast);
   virtual void visit(NestedStatementExpressionAST* ast);
   virtual void visit(NestedExpressionAST* ast);
   virtual void visit(IdExpressionAST* ast);
@@ -152,6 +153,10 @@ class ASTVisitor {
   virtual void visit(BracedInitListAST* ast);
   virtual void visit(ParenInitializerAST* ast);
 
+  // GenericAssociationAST
+  virtual void visit(DefaultGenericAssociationAST* ast);
+  virtual void visit(TypeGenericAssociationAST* ast);
+
   // DesignatorAST
   virtual void visit(DotDesignatorAST* ast);
   virtual void visit(SubscriptDesignatorAST* ast);
diff --git a/src/parser/cxx/flatbuffers/ast_decoder.cc b/src/parser/cxx/flatbuffers/ast_decoder.cc
index 94a5298d..d446cbd8 100644
--- a/src/parser/cxx/flatbuffers/ast_decoder.cc
+++ b/src/parser/cxx/flatbuffers/ast_decoder.cc
@@ -246,6 +246,9 @@ auto ASTDecoder::decodeExpression(const void* ptr, io::Expression type)
     case io::Expression_ThisExpression:
       return decodeThisExpression(
           reinterpret_cast<const io::ThisExpression*>(ptr));
+    case io::Expression_GenericSelectionExpression:
+      return decodeGenericSelectionExpression(
+          reinterpret_cast<const io::GenericSelectionExpression*>(ptr));
     case io::Expression_NestedStatementExpression:
       return decodeNestedStatementExpression(
           reinterpret_cast<const io::NestedStatementExpression*>(ptr));
@@ -400,6 +403,21 @@ auto ASTDecoder::decodeExpression(const void* ptr, io::Expression type)
   }  // switch
 }
 
+auto ASTDecoder::decodeGenericAssociation(const void* ptr,
+                                          io::GenericAssociation type)
+    -> GenericAssociationAST* {
+  switch (type) {
+    case io::GenericAssociation_DefaultGenericAssociation:
+      return decodeDefaultGenericAssociation(
+          reinterpret_cast<const io::DefaultGenericAssociation*>(ptr));
+    case io::GenericAssociation_TypeGenericAssociation:
+      return decodeTypeGenericAssociation(
+          reinterpret_cast<const io::TypeGenericAssociation*>(ptr));
+    default:
+      return nullptr;
+  }  // switch
+}
+
 auto ASTDecoder::decodeDesignator(const void* ptr, io::Designator type)
     -> DesignatorAST* {
   switch (type) {
@@ -1921,6 +1939,32 @@ auto ASTDecoder::decodeThisExpression(const io::ThisExpression* node)
   return ast;
 }
 
+auto ASTDecoder::decodeGenericSelectionExpression(
+    const io::GenericSelectionExpression* node)
+    -> GenericSelectionExpressionAST* {
+  if (!node) return nullptr;
+
+  auto ast = new (pool_) GenericSelectionExpressionAST();
+  ast->genericLoc = SourceLocation(node->generic_loc());
+  ast->lparenLoc = SourceLocation(node->lparen_loc());
+  ast->expression =
+      decodeExpression(node->expression(), node->expression_type());
+  ast->commaLoc = SourceLocation(node->comma_loc());
+  if (node->generic_association_list()) {
+    auto* inserter = &ast->genericAssociationList;
+    for (std::uint32_t i = 0; i < node->generic_association_list()->size();
+         ++i) {
+      *inserter = new (pool_) List(decodeGenericAssociation(
+          node->generic_association_list()->Get(i),
+          io::GenericAssociation(
+              node->generic_association_list_type()->Get(i))));
+      inserter = &(*inserter)->next;
+    }
+  }
+  ast->rparenLoc = SourceLocation(node->rparen_loc());
+  return ast;
+}
+
 auto ASTDecoder::decodeNestedStatementExpression(
     const io::NestedStatementExpression* node)
     -> NestedStatementExpressionAST* {
@@ -2709,6 +2753,31 @@ auto ASTDecoder::decodeParenInitializer(const io::ParenInitializer* node)
   return ast;
 }
 
+auto ASTDecoder::decodeDefaultGenericAssociation(
+    const io::DefaultGenericAssociation* node)
+    -> DefaultGenericAssociationAST* {
+  if (!node) return nullptr;
+
+  auto ast = new (pool_) DefaultGenericAssociationAST();
+  ast->defaultLoc = SourceLocation(node->default_loc());
+  ast->colonLoc = SourceLocation(node->colon_loc());
+  ast->expression =
+      decodeExpression(node->expression(), node->expression_type());
+  return ast;
+}
+
+auto ASTDecoder::decodeTypeGenericAssociation(
+    const io::TypeGenericAssociation* node) -> TypeGenericAssociationAST* {
+  if (!node) return nullptr;
+
+  auto ast = new (pool_) TypeGenericAssociationAST();
+  ast->typeId = decodeTypeId(node->type_id());
+  ast->colonLoc = SourceLocation(node->colon_loc());
+  ast->expression =
+      decodeExpression(node->expression(), node->expression_type());
+  return ast;
+}
+
 auto ASTDecoder::decodeDotDesignator(const io::DotDesignator* node)
     -> DotDesignatorAST* {
   if (!node) return nullptr;
diff --git a/src/parser/cxx/flatbuffers/ast_encoder.cc b/src/parser/cxx/flatbuffers/ast_encoder.cc
index b4350e75..2ffa05a5 100644
--- a/src/parser/cxx/flatbuffers/ast_encoder.cc
+++ b/src/parser/cxx/flatbuffers/ast_encoder.cc
@@ -152,6 +152,19 @@ auto ASTEncoder::acceptExpression(ExpressionAST* ast)
   return {offset, type};
 }
 
+auto ASTEncoder::acceptGenericAssociation(GenericAssociationAST* ast)
+    -> std::tuple<flatbuffers::Offset<>, std::uint32_t> {
+  if (!ast) return {};
+  flatbuffers::Offset<> offset;
+  std::uint32_t type = 0;
+  std::swap(offset, offset_);
+  std::swap(type, type_);
+  ast->accept(this);
+  std::swap(offset, offset_);
+  std::swap(type, type_);
+  return {offset, type};
+}
+
 auto ASTEncoder::acceptDesignator(DesignatorAST* ast)
     -> std::tuple<flatbuffers::Offset<>, std::uint32_t> {
   if (!ast) return {};
@@ -1906,6 +1919,39 @@ void ASTEncoder::visit(ThisExpressionAST* ast) {
   type_ = io::Expression_ThisExpression;
 }
 
+void ASTEncoder::visit(GenericSelectionExpressionAST* ast) {
+  const auto [expression, expressionType] = acceptExpression(ast->expression);
+
+  std::vector<flatbuffers::Offset<>> genericAssociationListOffsets;
+  std::vector<std::underlying_type_t<io::GenericAssociation>>
+      genericAssociationListTypes;
+
+  for (auto node : ListView{ast->genericAssociationList}) {
+    if (!node) continue;
+    const auto [offset, type] = acceptGenericAssociation(node);
+    genericAssociationListOffsets.push_back(offset);
+    genericAssociationListTypes.push_back(type);
+  }
+
+  auto genericAssociationListOffsetsVector =
+      fbb_.CreateVector(genericAssociationListOffsets);
+  auto genericAssociationListTypesVector =
+      fbb_.CreateVector(genericAssociationListTypes);
+
+  io::GenericSelectionExpression::Builder builder{fbb_};
+  builder.add_generic_loc(ast->genericLoc.index());
+  builder.add_lparen_loc(ast->lparenLoc.index());
+  builder.add_expression(expression);
+  builder.add_expression_type(static_cast<io::Expression>(expressionType));
+  builder.add_comma_loc(ast->commaLoc.index());
+  builder.add_generic_association_list(genericAssociationListOffsetsVector);
+  builder.add_generic_association_list_type(genericAssociationListTypesVector);
+  builder.add_rparen_loc(ast->rparenLoc.index());
+
+  offset_ = builder.Finish().Union();
+  type_ = io::Expression_GenericSelectionExpression;
+}
+
 void ASTEncoder::visit(NestedStatementExpressionAST* ast) {
   const auto statement = accept(ast->statement);
 
@@ -2928,6 +2974,34 @@ void ASTEncoder::visit(ParenInitializerAST* ast) {
   type_ = io::Expression_ParenInitializer;
 }
 
+void ASTEncoder::visit(DefaultGenericAssociationAST* ast) {
+  const auto [expression, expressionType] = acceptExpression(ast->expression);
+
+  io::DefaultGenericAssociation::Builder builder{fbb_};
+  builder.add_default_loc(ast->defaultLoc.index());
+  builder.add_colon_loc(ast->colonLoc.index());
+  builder.add_expression(expression);
+  builder.add_expression_type(static_cast<io::Expression>(expressionType));
+
+  offset_ = builder.Finish().Union();
+  type_ = io::GenericAssociation_DefaultGenericAssociation;
+}
+
+void ASTEncoder::visit(TypeGenericAssociationAST* ast) {
+  const auto typeId = accept(ast->typeId);
+
+  const auto [expression, expressionType] = acceptExpression(ast->expression);
+
+  io::TypeGenericAssociation::Builder builder{fbb_};
+  builder.add_type_id(typeId.o);
+  builder.add_colon_loc(ast->colonLoc.index());
+  builder.add_expression(expression);
+  builder.add_expression_type(static_cast<io::Expression>(expressionType));
+
+  offset_ = builder.Finish().Union();
+  type_ = io::GenericAssociation_TypeGenericAssociation;
+}
+
 void ASTEncoder::visit(DotDesignatorAST* ast) {
   flatbuffers::Offset<flatbuffers::String> identifier;
   if (ast->identifier) {
diff --git a/src/parser/cxx/parser.cc b/src/parser/cxx/parser.cc
index 4bda41b5..c5ea3b8a 100644
--- a/src/parser/cxx/parser.cc
+++ b/src/parser/cxx/parser.cc
@@ -689,6 +689,7 @@ auto Parser::parse_primary_expression(ExpressionAST*& yyast,
                                       const ExprContext& ctx) -> bool {
   if (parse_builtin_call_expression(yyast, ctx)) return true;
   if (parse_builtin_offsetof_expression(yyast, ctx)) return true;
+  if (parse_generic_selection_expression(yyast, ctx)) return true;
   if (parse_this_expression(yyast)) return true;
   if (parse_literal(yyast)) return true;
   if (parse_lambda_expression(yyast)) return true;
@@ -1432,6 +1433,71 @@ auto Parser::parse_this_expression(ExpressionAST*& yyast) -> bool {
   return true;
 }
 
+auto Parser::parse_generic_selection_expression(ExpressionAST*& yyast,
+                                                const ExprContext&) -> bool {
+  SourceLocation genericLoc;
+  if (!match(TokenKind::T__GENERIC, genericLoc)) return false;
+
+  auto ast = make_node<GenericSelectionExpressionAST>(pool_);
+  yyast = ast;
+
+  expect(TokenKind::T_LPAREN, ast->lparenLoc);
+  ast->genericLoc = genericLoc;
+
+  parse_assignment_expression(ast->expression, ExprContext{});
+
+  expect(TokenKind::T_COMMA, ast->commaLoc);
+
+  auto it = &ast->genericAssociationList;
+
+  GenericAssociationAST* association = nullptr;
+  parse_generic_association(association);
+
+  if (association) {
+    *it = make_list_node(pool_, association);
+    it = &(*it)->next;
+  }
+
+  SourceLocation commaLoc;
+  while (match(TokenKind::T_COMMA, commaLoc)) {
+    GenericAssociationAST* association = nullptr;
+    parse_generic_association(association);
+
+    if (association) {
+      *it = make_list_node(pool_, association);
+      it = &(*it)->next;
+    }
+  }
+
+  expect(TokenKind::T_RPAREN, ast->rparenLoc);
+
+  return true;
+}
+
+void Parser::parse_generic_association(GenericAssociationAST*& yyast) {
+  if (SourceLocation defaultLoc; match(TokenKind::T_DEFAULT, defaultLoc)) {
+    auto ast = make_node<DefaultGenericAssociationAST>(pool_);
+    yyast = ast;
+
+    ast->defaultLoc = defaultLoc;
+    expect(TokenKind::T_COLON, ast->colonLoc);
+    parse_assignment_expression(ast->expression, ExprContext{});
+
+    return;
+  }
+
+  auto ast = make_node<TypeGenericAssociationAST>(pool_);
+  yyast = ast;
+
+  if (!parse_type_id(ast->typeId)) {
+    parse_error("expected a type id");
+  }
+
+  expect(TokenKind::T_COLON, ast->colonLoc);
+
+  parse_assignment_expression(ast->expression, ExprContext{});
+}
+
 auto Parser::parse_nested_expession(ExpressionAST*& yyast,
                                     const ExprContext& ctx) -> bool {
   SourceLocation lparenLoc;
diff --git a/src/parser/cxx/parser.h b/src/parser/cxx/parser.h
index 9b253f7f..01a43d34 100644
--- a/src/parser/cxx/parser.h
+++ b/src/parser/cxx/parser.h
@@ -209,6 +209,10 @@ class Parser final {
   [[nodiscard]] auto parse_simple_capture(LambdaCaptureAST*& yyast) -> bool;
   [[nodiscard]] auto parse_init_capture(LambdaCaptureAST*& yyast) -> bool;
   [[nodiscard]] auto parse_this_expression(ExpressionAST*& yyast) -> bool;
+  [[nodiscard]] auto parse_generic_selection_expression(ExpressionAST*& yyast,
+                                                        const ExprContext& ctx)
+      -> bool;
+  void parse_generic_association(GenericAssociationAST*& yyast);
   [[nodiscard]] auto parse_nested_expession(ExpressionAST*& yyast,
                                             const ExprContext& ctx) -> bool;
   [[nodiscard]] auto parse_fold_expression(ExpressionAST*& yyast,
diff --git a/src/parser/cxx/private/ast_decoder.h b/src/parser/cxx/private/ast_decoder.h
index 7a4d81a2..f1d68bab 100644
--- a/src/parser/cxx/private/ast_decoder.h
+++ b/src/parser/cxx/private/ast_decoder.h
@@ -44,6 +44,8 @@ class ASTDecoder {
       -> DeclarationAST*;
   auto decodeStatement(const void* ptr, io::Statement type) -> StatementAST*;
   auto decodeExpression(const void* ptr, io::Expression type) -> ExpressionAST*;
+  auto decodeGenericAssociation(const void* ptr, io::GenericAssociation type)
+      -> GenericAssociationAST*;
   auto decodeDesignator(const void* ptr, io::Designator type) -> DesignatorAST*;
   auto decodeTemplateParameter(const void* ptr, io::TemplateParameter type)
       -> TemplateParameterAST*;
@@ -197,6 +199,9 @@ class ASTDecoder {
       -> ObjectLiteralExpressionAST*;
   auto decodeThisExpression(const io::ThisExpression* node)
       -> ThisExpressionAST*;
+  auto decodeGenericSelectionExpression(
+      const io::GenericSelectionExpression* node)
+      -> GenericSelectionExpressionAST*;
   auto decodeNestedStatementExpression(
       const io::NestedStatementExpression* node)
       -> NestedStatementExpressionAST*;
@@ -301,6 +306,12 @@ class ASTDecoder {
   auto decodeParenInitializer(const io::ParenInitializer* node)
       -> ParenInitializerAST*;
 
+  auto decodeDefaultGenericAssociation(
+      const io::DefaultGenericAssociation* node)
+      -> DefaultGenericAssociationAST*;
+  auto decodeTypeGenericAssociation(const io::TypeGenericAssociation* node)
+      -> TypeGenericAssociationAST*;
+
   auto decodeDotDesignator(const io::DotDesignator* node) -> DotDesignatorAST*;
   auto decodeSubscriptDesignator(const io::SubscriptDesignator* node)
       -> SubscriptDesignatorAST*;
diff --git a/src/parser/cxx/private/ast_encoder.h b/src/parser/cxx/private/ast_encoder.h
index 5009061e..b2935577 100644
--- a/src/parser/cxx/private/ast_encoder.h
+++ b/src/parser/cxx/private/ast_encoder.h
@@ -71,6 +71,9 @@ class ASTEncoder : ASTVisitor {
   auto acceptExpression(ExpressionAST* ast)
       -> std::tuple<flatbuffers::Offset<>, std::uint32_t>;
 
+  auto acceptGenericAssociation(GenericAssociationAST* ast)
+      -> std::tuple<flatbuffers::Offset<>, std::uint32_t>;
+
   auto acceptDesignator(DesignatorAST* ast)
       -> std::tuple<flatbuffers::Offset<>, std::uint32_t>;
 
@@ -188,6 +191,7 @@ class ASTEncoder : ASTVisitor {
   void visit(UserDefinedStringLiteralExpressionAST* ast) override;
   void visit(ObjectLiteralExpressionAST* ast) override;
   void visit(ThisExpressionAST* ast) override;
+  void visit(GenericSelectionExpressionAST* ast) override;
   void visit(NestedStatementExpressionAST* ast) override;
   void visit(NestedExpressionAST* ast) override;
   void visit(IdExpressionAST* ast) override;
@@ -239,6 +243,9 @@ class ASTEncoder : ASTVisitor {
   void visit(BracedInitListAST* ast) override;
   void visit(ParenInitializerAST* ast) override;
 
+  void visit(DefaultGenericAssociationAST* ast) override;
+  void visit(TypeGenericAssociationAST* ast) override;
+
   void visit(DotDesignatorAST* ast) override;
   void visit(SubscriptDesignatorAST* ast) override;
 
diff --git a/src/parser/cxx/private/c_keywords-priv.h b/src/parser/cxx/private/c_keywords-priv.h
index 0c542797..a9dfd092 100644
--- a/src/parser/cxx/private/c_keywords-priv.h
+++ b/src/parser/cxx/private/c_keywords-priv.h
@@ -1440,4 +1440,4 @@ static auto classifyC(const char* s, int n) -> cxx::TokenKind {
     default:
       return cxx::TokenKind::T_IDENTIFIER;
   }  // switch
-}
+}
\ No newline at end of file
diff --git a/src/parser/cxx/private/keywords-priv.h b/src/parser/cxx/private/keywords-priv.h
index b602a7bf..8c26f5d8 100644
--- a/src/parser/cxx/private/keywords-priv.h
+++ b/src/parser/cxx/private/keywords-priv.h
@@ -1822,4 +1822,4 @@ static auto classify(const char* s, int n) -> cxx::TokenKind {
     default:
       return cxx::TokenKind::T_IDENTIFIER;
   }  // switch
-}
+}
\ No newline at end of file
diff --git a/src/parser/cxx/private/pp_directives-priv.h b/src/parser/cxx/private/pp_directives-priv.h
index 5a73e324..f6cbc0b8 100644
--- a/src/parser/cxx/private/pp_directives-priv.h
+++ b/src/parser/cxx/private/pp_directives-priv.h
@@ -281,4 +281,4 @@ static auto classifyDirective(const char* s, int n)
     default:
       return PreprocessorDirectiveKind::T_IDENTIFIER;
   }  // switch
-}
+}
\ No newline at end of file
diff --git a/src/parser/cxx/symbols.h b/src/parser/cxx/symbols.h
index d9fcfc47..966b0f5f 100644
--- a/src/parser/cxx/symbols.h
+++ b/src/parser/cxx/symbols.h
@@ -136,7 +136,7 @@ class Symbol {
   [[nodiscard]] auto next() const -> Symbol*;
 
 #define PROCESS_SYMBOL(S) \
-  [[nodiscard]] auto is##S() const->bool { return kind_ == SymbolKind::k##S; }
+  [[nodiscard]] auto is##S() const -> bool { return kind_ == SymbolKind::k##S; }
   CXX_FOR_EACH_SYMBOL(PROCESS_SYMBOL)
 #undef PROCESS_SYMBOL
 
@@ -816,7 +816,7 @@ auto visit(Visitor&& visitor, Symbol* symbol) {
 }
 
 #define PROCESS_SYMBOL(S)                                \
-  inline auto is##S##Symbol(Symbol* symbol)->bool {      \
+  inline auto is##S##Symbol(Symbol* symbol) -> bool {    \
     return symbol && symbol->kind() == SymbolKind::k##S; \
   }
 
diff --git a/src/parser/cxx/type_checker.cc b/src/parser/cxx/type_checker.cc
index 81ae8fe0..9b43065b 100644
--- a/src/parser/cxx/type_checker.cc
+++ b/src/parser/cxx/type_checker.cc
@@ -149,6 +149,7 @@ struct TypeChecker::Visitor {
   void operator()(UserDefinedStringLiteralExpressionAST* ast);
   void operator()(ObjectLiteralExpressionAST* ast);
   void operator()(ThisExpressionAST* ast);
+  void operator()(GenericSelectionExpressionAST* ast);
   void operator()(NestedStatementExpressionAST* ast);
   void operator()(NestedExpressionAST* ast);
   void operator()(IdExpressionAST* ast);
@@ -253,6 +254,8 @@ void TypeChecker::Visitor::operator()(ThisExpressionAST* ast) {
   }
 }
 
+void TypeChecker::Visitor::operator()(GenericSelectionExpressionAST* ast) {}
+
 void TypeChecker::Visitor::operator()(NestedStatementExpressionAST* ast) {}
 
 void TypeChecker::Visitor::operator()(NestedExpressionAST* ast) {
diff --git a/tests/unit_tests/ast/generic_selection_01.c b/tests/unit_tests/ast/generic_selection_01.c
new file mode 100644
index 00000000..ed29493d
--- /dev/null
+++ b/tests/unit_tests/ast/generic_selection_01.c
@@ -0,0 +1,126 @@
+// clang-format off
+// RUN: %cxx -verify -fcheck -ast-dump -xc %s | %filecheck %s --match-full-lines
+// clang-format on
+
+int main() {
+  (void)_Generic(1, default: "default");
+  (void)_Generic(1, default: "default", int: "int", const char*: "const char*");
+  (void)_Generic(1, int: "int", const char*: "const char*", default: "default");
+  (void)_Generic(1, int: "int", const char*: "const char*");
+}
+
+// clang-format off
+//      CHECK:translation-unit
+// CHECK-NEXT:  declaration-list
+// CHECK-NEXT:    function-definition
+// CHECK-NEXT:      decl-specifier-list
+// CHECK-NEXT:        integral-type-specifier
+// CHECK-NEXT:          specifier: int
+// CHECK-NEXT:      declarator: declarator
+// CHECK-NEXT:        core-declarator: id-declarator
+// CHECK-NEXT:          unqualified-id: name-id
+// CHECK-NEXT:            identifier: main
+// CHECK-NEXT:        declarator-chunk-list
+// CHECK-NEXT:          function-declarator-chunk
+// CHECK-NEXT:      function-body: compound-statement-function-body
+// CHECK-NEXT:        statement: compound-statement
+// CHECK-NEXT:          statement-list
+// CHECK-NEXT:            expression-statement
+// CHECK-NEXT:              expression: cast-expression [prvalue void]
+// CHECK-NEXT:                type-id: type-id
+// CHECK-NEXT:                  type-specifier-list
+// CHECK-NEXT:                    void-type-specifier
+// CHECK-NEXT:                expression: generic-selection-expression
+// CHECK-NEXT:                  expression: int-literal-expression [prvalue int]
+// CHECK-NEXT:                    literal: 1
+// CHECK-NEXT:                  generic-association-list
+// CHECK-NEXT:                    default-generic-association
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [8]]
+// CHECK-NEXT:                        literal: "default"
+// CHECK-NEXT:            expression-statement
+// CHECK-NEXT:              expression: cast-expression [prvalue void]
+// CHECK-NEXT:                type-id: type-id
+// CHECK-NEXT:                  type-specifier-list
+// CHECK-NEXT:                    void-type-specifier
+// CHECK-NEXT:                expression: generic-selection-expression
+// CHECK-NEXT:                  expression: int-literal-expression [prvalue int]
+// CHECK-NEXT:                    literal: 1
+// CHECK-NEXT:                  generic-association-list
+// CHECK-NEXT:                    default-generic-association
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [8]]
+// CHECK-NEXT:                        literal: "default"
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: int
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [4]]
+// CHECK-NEXT:                        literal: "int"
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          const-qualifier
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: char
+// CHECK-NEXT:                        declarator: declarator
+// CHECK-NEXT:                          ptr-op-list
+// CHECK-NEXT:                            pointer-operator
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [12]]
+// CHECK-NEXT:                        literal: "const char*"
+// CHECK-NEXT:            expression-statement
+// CHECK-NEXT:              expression: cast-expression [prvalue void]
+// CHECK-NEXT:                type-id: type-id
+// CHECK-NEXT:                  type-specifier-list
+// CHECK-NEXT:                    void-type-specifier
+// CHECK-NEXT:                expression: generic-selection-expression
+// CHECK-NEXT:                  expression: int-literal-expression [prvalue int]
+// CHECK-NEXT:                    literal: 1
+// CHECK-NEXT:                  generic-association-list
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: int
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [4]]
+// CHECK-NEXT:                        literal: "int"
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          const-qualifier
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: char
+// CHECK-NEXT:                        declarator: declarator
+// CHECK-NEXT:                          ptr-op-list
+// CHECK-NEXT:                            pointer-operator
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [12]]
+// CHECK-NEXT:                        literal: "const char*"
+// CHECK-NEXT:                    default-generic-association
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [8]]
+// CHECK-NEXT:                        literal: "default"
+// CHECK-NEXT:            expression-statement
+// CHECK-NEXT:              expression: cast-expression [prvalue void]
+// CHECK-NEXT:                type-id: type-id
+// CHECK-NEXT:                  type-specifier-list
+// CHECK-NEXT:                    void-type-specifier
+// CHECK-NEXT:                expression: generic-selection-expression
+// CHECK-NEXT:                  expression: int-literal-expression [prvalue int]
+// CHECK-NEXT:                    literal: 1
+// CHECK-NEXT:                  generic-association-list
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: int
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [4]]
+// CHECK-NEXT:                        literal: "int"
+// CHECK-NEXT:                    type-generic-association
+// CHECK-NEXT:                      type-id: type-id
+// CHECK-NEXT:                        type-specifier-list
+// CHECK-NEXT:                          const-qualifier
+// CHECK-NEXT:                          integral-type-specifier
+// CHECK-NEXT:                            specifier: char
+// CHECK-NEXT:                        declarator: declarator
+// CHECK-NEXT:                          ptr-op-list
+// CHECK-NEXT:                            pointer-operator
+// CHECK-NEXT:                      expression: string-literal-expression [lvalue const char [12]]
+// CHECK-NEXT:                        literal: "const char*"