I cant' seem to find the correct types for context required for visiting cst

[aditya-kumarr]

I'm trying to replicate the selectStatement parser example from docs in typescript and can't get the types right

My tokens file

import { createToken, CstParser, Lexer, Rule } from "chevrotain";
const Identifier = createToken({
  name: "Identifier",
  pattern: /[a-zA-Z]\w*/,
});

const From = createToken({
  name: "From",
  pattern: /FROM/,
  longer_alt: Identifier,
});

const Select = createToken({
  name: "Select",
  pattern: /SELECT/,
  longer_alt: Identifier,
});

const Where = createToken({
  name: "Where",
  pattern: /WHERE/,
  longer_alt: Identifier,
});

const Comma = createToken({
  name: "Comma",
  pattern: /,/,
});

const GreaterThan = createToken({
  name: "GreaterThan",
  pattern: />/,
});

const LessThan = createToken({
  name: "LessThan",
  pattern: /</,
});

const Integer = createToken({
  name: "Integer",
  pattern: /0|[1-9]\d*/,
});

const WhiteSpace = createToken({
  name: "Whitespace",
  pattern: /\s+/,
  group: Lexer.SKIPPED,
});

let allTokens = [
  WhiteSpace,
  // "keywords" appear before the Identifier
  Select,
  From,
  Where,
  Comma,
  // The Identifier must appear after the keywords because all keywords are valid identifiers.
  Identifier,
  Integer,
  GreaterThan,
  LessThan,
];
export const SelectLexer = new Lexer(allTokens);

class SelectParser extends CstParser {
  constructor() {
    super(allTokens);
    // this.selectClause();
    this.performSelfAnalysis();
  }
  public selectStatement = this.RULE("selectStatement", () => {
    this.SUBRULE(this.selectClause);
    this.SUBRULE(this.fromClause);
    this.OPTION(() => {
      this.SUBRULE(this.whereClause);
    });
  });

  private selectClause = this.RULE("selectClause", () => {
    this.CONSUME(Select);
    this.AT_LEAST_ONE_SEP({
      SEP: Comma,
      DEF: () => {
        this.CONSUME(Identifier);
      },
    });
  });
  private fromClause = this.RULE("fromClause", () => {
    this.CONSUME(From);
    this.CONSUME(Identifier);
  });
  private whereClause = this.RULE("whereClause", () => {
    this.CONSUME(Where);
    this.SUBRULE(this.expression);
  });

  private expression = this.RULE("expression", () => {
    this.SUBRULE(this.atomicExpression, { LABEL: "lhs" });
    this.SUBRULE(this.relationalOperator);
    this.SUBRULE2(this.atomicExpression, { LABEL: "rhs" });
  });

  private atomicExpression = this.RULE("atomicExpression", () => {
    this.OR([
      {
        ALT: () => this.CONSUME(Integer),
      },
      {
        ALT: () => this.CONSUME(Identifier),
      },
    ]);
  });
  private relationalOperator = this.RULE("relationalOperator", () => {
    this.OR([
      { ALT: () => this.CONSUME(GreaterThan) },
      { ALT: () => this.CONSUME(LessThan) },
    ]);
  });
}

export const selectParser = new SelectParser();

export const productions: Record<string, Rule> =
  selectParser.getGAstProductions();

the types are generated correctly but I don't know what to pass in the ctx here

class SQLToAstVisitor extends BaseSQLVisitor {
  constructor() {
    super();
    this.validateVisitor();
  }

  // The Ctx argument is the current CSTNode's children.
  selectClause(ctx:???) {
    // Each Terminal or Non-Terminal in a grammar rule are collected into
    // an array with the same name(key) in the ctx object.
    let columns = ctx.Identifier.map((identToken) => identToken.image);

    return {
      type: "SELECT_CLAUSE",
      columns: columns,
    };
  }
}

It certainly not the ICstNodeVisitor generated by script

This is my d.ts file in case that helps

import type { CstNode, ICstVisitor, IToken } from "chevrotain";

export interface SelectStatementCstNode extends CstNode {
  name: "selectStatement";
  children: SelectStatementCstChildren;
}

export type SelectStatementCstChildren = {
  selectClause: SelectClauseCstNode[];
  fromClause: FromClauseCstNode[];
  whereClause?: WhereClauseCstNode[];
};

export interface SelectClauseCstNode extends CstNode {
  name: "selectClause";
  children: SelectClauseCstChildren;
}

export type SelectClauseCstChildren = {
  Select: IToken[];
  Identifier: IToken[];
  Comma?: IToken[];
};

export interface FromClauseCstNode extends CstNode {
  name: "fromClause";
  children: FromClauseCstChildren;
}

export type FromClauseCstChildren = {
  From: IToken[];
  Identifier: IToken[];
};

export interface WhereClauseCstNode extends CstNode {
  name: "whereClause";
  children: WhereClauseCstChildren;
}

export type WhereClauseCstChildren = {
  Where: IToken[];
  expression: ExpressionCstNode[];
};

export interface ExpressionCstNode extends CstNode {
  name: "expression";
  children: ExpressionCstChildren;
}

export type ExpressionCstChildren = {
  lhs: AtomicExpressionCstNode[];
  relationalOperator: RelationalOperatorCstNode[];
  rhs: AtomicExpressionCstNode[];
};

export interface AtomicExpressionCstNode extends CstNode {
  name: "atomicExpression";
  children: AtomicExpressionCstChildren;
}

export type AtomicExpressionCstChildren = {
  Integer?: IToken[];
  Identifier?: IToken[];
};

export interface RelationalOperatorCstNode extends CstNode {
  name: "relationalOperator";
  children: RelationalOperatorCstChildren;
}

export type RelationalOperatorCstChildren = {
  GreaterThan?: IToken[];
  LessThan?: IToken[];
};




export interface ICstNodeVisitor<IN, OUT> extends ICstVisitor<IN, OUT> {
  selectStatement(children: SelectStatementCstChildren, param?: IN): OUT;
  selectClause(children: SelectClauseCstChildren, param?: IN): OUT;
  fromClause(children: FromClauseCstChildren, param?: IN): OUT;
  whereClause(children: WhereClauseCstChildren, param?: IN): OUT;
  expression(children: ExpressionCstChildren, param?: IN): OUT;
  atomicExpression(children: AtomicExpressionCstChildren, param?: IN): OUT;
  relationalOperator(children: RelationalOperatorCstChildren, param?: IN): OUT;
}

[aditya-kumarr]

never mind found it, it's different for each case