@ton-community/tlb-parser/src/ast/nodes.ts

Parse TLB syntax into TypeScript objects

export abstract class ASTRootBase {
  // If the `parent` field is `null` it means that we've reached the root node.
  // only `Program` has `parent` as null.
  // All other nodes have valid node parents.
  // We define `parent` while building the tree
  // in the intermediate represtantation.
  readonly parent!: ASTBase | null

  // Node locations, start with `{ 1, 1 }`
  readonly locations!: {
    readonly line: number,
    readonly column: number,
  }

  // Attributes of this node, required for `walk` function, don't use directly.
  static readonly _attributes: string[] = []
}

export abstract class ASTBase extends ASTRootBase {
  override readonly parent!: ASTBase
}

export class Program extends ASTRootBase {
  static override readonly _attributes: string[] = ['declarations']
  override readonly parent: null = null

  constructor(
    readonly declarations: Declaration[],
  ) {
    super()
  }
}

export class Declaration extends ASTBase {
  static override readonly _attributes: string[] = [
    'constructorDef', 'fields', 'combinator',
  ]

  constructor(
    readonly constructorDef: Constructor,
    readonly fields: FieldDefinition[],
    readonly combinator: Combinator,
  ) {
    super()
  }
}

export class Constructor extends ASTBase {
  constructor(
    readonly name: string,
    readonly tag: string | null,
  ) {
    super()
  }

  getTagType(): 'binary' | 'hex' | null {
    if (this.tag === null) {
      return null
    }
    return this.tag.startsWith('$') ? 'binary' : 'hex'
  }
}

// Fields
// ------

export type FieldDefinition =
  | FieldBuiltinDef
  | FieldCurlyExprDef
  | FieldAnonymousDef
  | FieldNamedDef
  | FieldExprDef

export abstract class Field extends ASTBase {}

export const FieldBuiltinType = ['#', 'Type'] as const

export class FieldBuiltinDef extends Field {
  constructor(
    readonly name: string,
    readonly type: typeof FieldBuiltinType[number],
  ) {
    super()
  }
}

export class FieldCurlyExprDef extends Field {
  static override readonly _attributes: string[] = ['expr']

  constructor(
    readonly expr: Expression,
  ) {
    super()
  }
}

// TODO: I am not sure that `name` is allowed. Maybe it can only be `_`
// See https://github.com/ton-blockchain/ton/issues/540
export class FieldAnonymousDef extends Field {
  static override readonly _attributes: string[] = ['fields']

  constructor(
    readonly name: string | null,
    readonly isRef: boolean,
    readonly fields: FieldDefinition[],
  ) {
    super()
  }
}

export class FieldNamedDef extends Field {
  static override readonly _attributes: string[] = ['expr']

  constructor(
    readonly name: string,
    readonly expr: CondExpr | TypeExpr,
  ) {
    super()
  }
}

export class FieldExprDef extends Field {
  static override readonly _attributes: string[] = ['expr']

  constructor(
    readonly expr: CondExpr,
  ) {
    super()
  }
}

// Combinators
// -----------

export class Combinator extends ASTBase {
  static override readonly _attributes: string[] = ['args']

  constructor(
    readonly name: string,
    readonly args: TypeExpr[],
  ) {
    super()
  }
}

// Expressions
// -----------

export abstract class Expression extends ASTBase {}

// TODO: add validation that `dotExpr` cannot be set without `condExpr`
export class CondExpr extends Expression {
  static override readonly _attributes: string[] = ['left', 'condExpr']

  constructor(
    readonly left: TypeExpr,
    readonly dotExpr: number | null,
    readonly condExpr: TypeExpr,
  ) {
    super()
  }
}

export const CompareOperator = ['<=', '>=', '!=', '=', '<', '>'] as const

export class CompareExpr extends Expression {
  static override readonly _attributes: string[] = ['left', 'right']

  constructor(
    readonly left: SimpleExpr,
    readonly op: typeof CompareOperator[number],
    readonly right: SimpleExpr,
  ) {
    super()
  }
}

// TypeExpr

export type TypeExpr =
  | CellRefExpr
  | BuiltinExpr
  | CombinatorExpr
  | SimpleExpr

export class CellRefExpr extends Expression {
  static override readonly _attributes: string[] = ['expr']

  constructor(
    readonly expr: Expression,
  ) {
    super()
  }
}

export class BuiltinExpr extends Expression {}

export const BuiltinOneArgOperators = ['#<=', '#<', '##'] as const

export class BuiltinOneArgExpr extends BuiltinExpr {
  static override readonly _attributes: string[] = ['arg']

  constructor(
    readonly name: typeof BuiltinOneArgOperators[number],
    readonly arg: Reference,
  ) {
    super()
  }
}

export const BuiltinZeroArgsOperators = ['#'] as const

export class BuiltinZeroArgs extends BuiltinExpr {
  constructor(
    readonly name: typeof BuiltinZeroArgsOperators[number],
  ) {
    super()
  }
}

export class CombinatorExpr extends Expression {
  static override readonly _attributes: string[] = ['args']

  constructor(
    readonly name: string,
    readonly args: TypeExpr[],
  ) {
    super()
  }
}

// SimpleExpr

export type SimpleExpr =
  | NegateExpr
  | MathExpr
  | Reference

export const MathOperator = ['*', '+'] as const

export class MathExpr extends Expression {
  static override readonly _attributes: string[] = ['left', 'right']

  // TODO: narrower type for `left` and `right`?
  // TODO: use `SimpleExpr` and `number`?
  constructor(
    readonly left: SimpleExpr,
    readonly op: typeof MathOperator[number],
    readonly right: SimpleExpr,
  ) {
    super()
  }
}

export class NegateExpr extends Expression {
  static override readonly _attributes: string[] = ['expr']

  constructor(
    readonly expr: Expression,
  ) {
    super()
  }
}

export class RefExpr extends Expression {}

export type Reference = NameExpr | NumberExpr

export class NameExpr extends RefExpr {
  constructor(
    readonly name: string,
  ) {
    super()
  }
}

export class NumberExpr extends RefExpr {
  constructor(
    readonly num: number,
  ) {
    super()
  }
}