@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/node/aligned-modifier.ts

@@ -0,0 +1,21 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+export class AlignedModifier extends AbstractCompositeNode {
+  constructor(
+    public readonly alignedKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: OptionalNode<Token>,
+    public readonly bitCountModifierToken: OptionalNode<Token>,
+    public readonly closeParenthesisPunctuator: OptionalNode<Token>,
+    public readonly alignment: number,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.ALIGNED_MODIFIER,
+      children,
+    );
+  }
+}

package/src/ast/node/array-definition.ts

@@ -0,0 +1,44 @@
+import type {
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import { AbstractArrayDefinition } from "./abstract-array-definition.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AlignedModifier } from "./aligned-modifier.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { ExplicitArrayDimension } from "./explicit-array-dimension.ts";
+import type { Identifier } from "./identifier.ts";
+import type { ImplicitArrayDimension } from "./implicit-array-dimension.ts";
+import type { LengthAttribute } from "./length-attribute.ts";
+import type { PartialArrayDimension } from "./partial-array-dimension.ts";
+import type { Token } from "./token.ts";
+
+export class ArrayDefinition extends AbstractArrayDefinition {
+  constructor(
+    public readonly reservedKeyword: OptionalNode<Token>,
+    public readonly legacyKeyword: OptionalNode<Token>,
+    public readonly alignedModifier: OptionalNode<AlignedModifier>,
+    public readonly elementaryType: OptionalNode<ElementaryType>,
+    public readonly lengthAttribute: OptionalNode<LengthAttribute>,
+    public readonly classIdentifier: OptionalNode<Identifier>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly implicitArrayDimension: OptionalNode<
+      ImplicitArrayDimension
+    >,
+    public readonly dimensions: ZeroToManyList<
+      | ExplicitArrayDimension
+      | PartialArrayDimension
+    >,
+    semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.ARRAY_DEFINITION,
+      identifier,
+      semicolonPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/array-element-access.ts

@@ -0,0 +1,24 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ArrayElementAccess extends AbstractCompositeNode {
+  constructor(
+    public readonly openBracketPunctuator: RequiredNode<Token>,
+    public readonly index: RequiredNode<
+      AbstractExpression | NumberLiteral | Identifier
+    >,
+    public readonly closeBracketPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.ARRAY_ELEMENT_ACCESS,
+      children,
+    );
+  }
+}

package/src/ast/node/binary-expression.ts

@@ -0,0 +1,28 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { BinaryOperatorKind } from "./enum/binary-operator-kind.ts";
+import { ExpressionKind } from "./enum/expression-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class BinaryExpression extends AbstractExpression {
+  constructor(
+    public readonly leftOperand: RequiredNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    public readonly binaryOperator: RequiredNode<Token>,
+    public readonly rightOperand: RequiredNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    public readonly binaryOperatorKind: BinaryOperatorKind | undefined,
+    children: Array<AbstractNode>,
+  ) {
+    super(ExpressionKind.BINARY, children);
+  }
+}

package/src/ast/node/bit-modifier.ts

@@ -0,0 +1,24 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import type { AbstractClassId } from "./abstract-class-id.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class BitModifier extends AbstractCompositeNode {
+  constructor(
+    public readonly colonPunctuator: RequiredNode<Token>,
+    public readonly bitKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly length: RequiredNode<NumberLiteral>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly identifier: OptionalNode<Identifier>,
+    public readonly assignmentOperator: OptionalNode<Token>,
+    public readonly classId: RequiredNode<AbstractClassId>,
+    children: Array<AbstractNode>,
+  ) {
+    super(NodeKind.BIT_MODIFIER, children);
+  }
+}

package/src/ast/node/case-clause.ts

@@ -0,0 +1,30 @@
+import type {
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AbstractStatement } from "./abstract-statement.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class CaseClause extends AbstractCompositeNode {
+  constructor(
+    public readonly caseKeyword: RequiredNode<Token>,
+    public readonly value: RequiredNode<NumberLiteral>,
+    public readonly colonPunctuator: RequiredNode<Token>,
+    public readonly openBracePunctuator: OptionalNode<Token>,
+    public readonly statements: ZeroToManyList<AbstractStatement>,
+    public readonly breakKeyword: OptionalNode<Token>,
+    public readonly semicolonPunctuator: OptionalNode<Token>,
+    public readonly closeBracePunctuator: OptionalNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.CASE_CLAUSE,
+      children,
+    );
+  }
+}

package/src/ast/node/class-declaration.ts

@@ -0,0 +1,39 @@
+import type {
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { AlignedModifier } from "./aligned-modifier.ts";
+import type { BitModifier } from "./bit-modifier.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { ExpandableModifier } from "./expandable-modifier.ts";
+import type { ExtendsModifier } from "./extends-modifier.ts";
+import type { Identifier } from "./identifier.ts";
+import type { ParameterList } from "./parameter-list.ts";
+import type { Token } from "./token.ts";
+
+export class ClassDeclaration extends AbstractStatement {
+  constructor(
+    public readonly alignedModifier: OptionalNode<AlignedModifier>,
+    public readonly expandableModifier:
+      | OptionalNode<ExpandableModifier>
+      | undefined,
+    public readonly abstractKeyword: OptionalNode<Token>,
+    public readonly classKeyword: RequiredNode<Token>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly parameterList: OptionalNode<ParameterList>,
+    public readonly extendsModifier: OptionalNode<ExtendsModifier>,
+    public readonly bitModifier: OptionalNode<BitModifier>,
+    public readonly openBracePunctuator: RequiredNode<Token>,
+    public readonly statements: ZeroToManyList<AbstractStatement>,
+    public readonly closeBracePunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.CLASS_DECLARATION,
+      children,
+    );
+  }
+}

package/src/ast/node/class-definition.ts

@@ -0,0 +1,23 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { ParameterValueList } from "./parameter-value-list.ts";
+import type { Token } from "./token.ts";
+
+export class ClassDefinition extends AbstractStatement {
+  constructor(
+    public readonly legacyKeyword: OptionalNode<Token>,
+    public readonly classIdentifier: RequiredNode<Identifier>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly parameterValueList: OptionalNode<ParameterValueList>,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.CLASS_DEFINITION,
+      children,
+    );
+  }
+}

package/src/ast/node/class-id-range.ts

@@ -0,0 +1,17 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractClassId } from "./abstract-class-id.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { ClassId } from "./class-id.ts";
+import { ClassIdKind } from "./enum/class-id-kind.ts";
+import type { Token } from "./token.ts";
+
+export class ClassIdRange extends AbstractClassId {
+  constructor(
+    public readonly startClassId: RequiredNode<ClassId>,
+    public readonly rangeOperator: RequiredNode<Token>,
+    public readonly endClassId: RequiredNode<ClassId>,
+    children: Array<AbstractNode>,
+  ) {
+    super(ClassIdKind.RANGE, children);
+  }
+}

package/src/ast/node/class-id.ts

@@ -0,0 +1,14 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractClassId } from "./abstract-class-id.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ClassIdKind } from "./enum/class-id-kind.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+
+export class ClassId extends AbstractClassId {
+  constructor(
+    public readonly value: RequiredNode<NumberLiteral>,
+    children: Array<AbstractNode>,
+  ) {
+    super(ClassIdKind.SINGLE, children);
+  }
+}

package/src/ast/node/class-member-access.ts

@@ -0,0 +1,19 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { Token } from "./token.ts";
+
+export class ClassMemberAccess extends AbstractCompositeNode {
+  constructor(
+    public readonly classMemberAccessOperator: RequiredNode<Token>,
+    public readonly memberIdentifier: RequiredNode<Identifier>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.CLASS_MEMBER_ACCESS,
+      children,
+    );
+  }
+}

package/src/ast/node/compound-statement.ts

@@ -0,0 +1,19 @@
+import type { RequiredNode, ZeroToManyList } from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Token } from "./token.ts";
+
+export class CompoundStatement extends AbstractStatement {
+  constructor(
+    public readonly openBracePunctuator: RequiredNode<Token>,
+    public readonly statements: ZeroToManyList<AbstractStatement>,
+    public readonly closeBracePunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.COMPOUND,
+      children,
+    );
+  }
+}

package/src/ast/node/computed-array-definition.ts

@@ -0,0 +1,26 @@
+import type { OneToManyList, RequiredNode } from "../util/types.ts";
+import { AbstractArrayDefinition } from "./abstract-array-definition.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { ExplicitArrayDimension } from "./explicit-array-dimension.ts";
+import type { Identifier } from "./identifier.ts";
+import type { Token } from "./token.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+
+export class ComputedArrayDefinition extends AbstractArrayDefinition {
+  constructor(
+    public readonly computedKeyword: RequiredNode<Token>,
+    public readonly elementaryType: RequiredNode<ElementaryType>,
+    identifier: RequiredNode<Identifier>,
+    public readonly dimensions: OneToManyList<ExplicitArrayDimension>,
+    semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.COMPUTED_ARRAY_DEFINITION,
+      identifier,
+      semicolonPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/computed-elementary-type-definition.ts

@@ -0,0 +1,34 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractElementaryTypeDefinition } from "./abstract-elementary-type-definition.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ComputedElementaryTypeDefinition
+  extends AbstractElementaryTypeDefinition {
+  constructor(
+    public readonly computedKeyword: RequiredNode<Token>,
+    constKeyword: OptionalNode<Token>,
+    elementaryType: RequiredNode<ElementaryType>,
+    identifier: RequiredNode<Identifier>,
+    assignmentOperator: OptionalNode<Token>,
+    value: OptionalNode<AbstractExpression | Identifier | NumberLiteral>,
+    semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
+      constKeyword,
+      elementaryType,
+      identifier,
+      assignmentOperator,
+      value,
+      semicolonPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/default-clause.ts

@@ -0,0 +1,26 @@
+import type {
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AbstractStatement } from "./abstract-statement.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+export class DefaultClause extends AbstractCompositeNode {
+  constructor(
+    public readonly defaultKeyword: RequiredNode<Token>,
+    public readonly colonPunctuator: RequiredNode<Token>,
+    public readonly openBracePunctuator: OptionalNode<Token>,
+    public readonly statements: ZeroToManyList<AbstractStatement>,
+    public readonly closeBracePunctuator: OptionalNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.DEFAULT_CLAUSE,
+      children,
+    );
+  }
+}

package/src/ast/node/do-statement.ts

@@ -0,0 +1,28 @@
+import type { RequiredNode } from "../util/types.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { CompoundStatement } from "./compound-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class DoStatement extends AbstractStatement {
+  constructor(
+    public readonly doKeyword: RequiredNode<Token>,
+    public readonly compoundStatement: RequiredNode<CompoundStatement>,
+    public readonly whileKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly condition: RequiredNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(StatementKind.DO, children);
+  }
+}

package/src/ast/node/elementary-type-definition.ts

@@ -0,0 +1,49 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractElementaryTypeDefinition } from "./abstract-elementary-type-definition.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AlignedModifier } from "./aligned-modifier.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { Identifier } from "./identifier.ts";
+import type { LengthAttribute } from "./length-attribute.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+
+export class ElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
+  constructor(
+    public readonly reservedKeyword: OptionalNode<Token>,
+    public readonly legacyKeyword: OptionalNode<Token>,
+    constKeyword: OptionalNode<Token>,
+    public readonly alignedModifier: OptionalNode<AlignedModifier>,
+    elementaryType: RequiredNode<ElementaryType>,
+    public readonly lengthAttribute: RequiredNode<LengthAttribute>,
+    public readonly lookAheadOperator: OptionalNode<Token>,
+    identifier: RequiredNode<Identifier>,
+    assignmentOperator: OptionalNode<Token>,
+    value: OptionalNode<
+      | AbstractExpression
+      | NumberLiteral
+      | Identifier
+    >,
+    public readonly rangeOperator: OptionalNode<Token>,
+    public readonly endValue: OptionalNode<
+      | AbstractExpression
+      | NumberLiteral
+      | Identifier
+    >,
+    semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.ELEMENTARY_TYPE_DEFINITION,
+      constKeyword,
+      elementaryType,
+      identifier,
+      assignmentOperator,
+      value,
+      semicolonPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/elementary-type-output-value.ts

@@ -0,0 +1,19 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { LengthAttribute } from "./length-attribute.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { RequiredNode } from "../util/types.ts";
+
+export class ElementaryTypeOutputValue extends AbstractCompositeNode {
+  constructor(
+    public readonly elementaryType: RequiredNode<ElementaryType>,
+    public readonly lengthAttribute: RequiredNode<LengthAttribute>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE,
+      children,
+    );
+  }
+}

package/src/ast/node/elementary-type.ts

@@ -0,0 +1,18 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+export class ElementaryType extends AbstractCompositeNode {
+  constructor(
+    public readonly unsignedQualifierKeyword: OptionalNode<Token>,
+    public readonly typeKeyword: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.ELEMENTARY_TYPE,
+      children,
+    );
+  }
+}

package/src/ast/node/enum/array-dimension-kind.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum representing different kinds of array dimensions.
+ */
+export enum ArrayDimensionKind {
+  /** Explicit array dimension */
+  EXPLICIT,
+  /** Partial array dimension */
+  PARTIAL,
+  /** Implicit array dimension */
+  IMPLICIT,
+}

package/src/ast/node/enum/binary-operator-kind.ts

@@ -0,0 +1,41 @@
+/**
+ * Enum representing different kinds of binary operators.
+ */
+export enum BinaryOperatorKind {
+  /** Assignment operator */
+  ASSIGNMENT,
+  /** Multiplication operator */
+  MULTIPLY,
+  /** Division operator */
+  DIVIDE,
+  /** Modulus operator */
+  MODULUS,
+  /** Addition operator */
+  ADD,
+  /** Subtraction operator */
+  SUBTRACT,
+  /** Shift left operator */
+  SHIFT_LEFT,
+  /** Shift right operator */
+  SHIFT_RIGHT,
+  /** Less than operator */
+  LESS_THAN,
+  /** Less than or equal operator */
+  LESS_THAN_OR_EQUAL,
+  /** Greater than operator */
+  GREATER_THAN,
+  /** Greater than or equal operator */
+  GREATER_THAN_OR_EQUAL,
+  /** Equal operator */
+  EQUAL,
+  /** Not equal operator */
+  NOT_EQUAL,
+  /** Bitwise AND operator */
+  BITWISE_AND,
+  /** Bitwise OR operator */
+  BITWISE_OR,
+  /** Logical AND operator */
+  LOGICAL_AND,
+  /** Logical OR operator */
+  LOGICAL_OR,
+}

package/src/ast/node/enum/class-id-kind.ts

@@ -0,0 +1,12 @@
+/**
+ * Enum representing different kinds of class IDs.
+ * This enum is used to categorize different types of class IDs.
+ */
+export enum ClassIdKind {
+  /** Single class ID */
+  SINGLE,
+  /** Range class ID */
+  RANGE,
+  /** Extended range class ID */
+  EXTENDED_RANGE,
+}

package/src/ast/node/enum/elementary-type-kind.ts

@@ -0,0 +1,13 @@
+/**
+ * Enum representing different kinds of elementary types.
+ */
+export enum ElementaryTypeKind {
+  /** Integer type */
+  INTEGER,
+  /** Unsigned integer type */
+  UNSIGNED_INTEGER,
+  /** Floating point type */
+  FLOATING_POINT,
+  /** Bit type */
+  BIT,
+}

package/src/ast/node/enum/expression-kind.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum representing different kinds of expressions.
+ */
+export enum ExpressionKind {
+  /** Binary expression */
+  BINARY,
+  /** Lengthof expression */
+  LENGTHOF,
+  /** Unary expression */
+  UNARY,
+}