@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,57 @@
+/**
+ * Enum representing different kinds of nodes.
+ */
+export enum NodeKind {
+  /** Error placeholder for unexpected node */
+  UNEXPECTED_ERROR = -1,
+  /** Output value node */
+  AGGREGATE_OUTPUT_VALUE,
+  /** Aligned modifier node */
+  ALIGNED_MODIFIER,
+  /** Array dimension node */
+  ARRAY_DIMENSION,
+  /** Array element access node */
+  ARRAY_ELEMENT_ACCESS,
+  /** Bit modifier node */
+  BIT_MODIFIER,
+  /** Switch case clause node */
+  CASE_CLAUSE,
+  /** Class ID node */
+  CLASS_ID,
+  /** Class member access node */
+  CLASS_MEMBER_ACCESS,
+  /** Switch default clause node */
+  DEFAULT_CLAUSE,
+  /** Elementary type node */
+  ELEMENTARY_TYPE,
+  /** Elementary type output value node */
+  ELEMENTARY_TYPE_OUTPUT_VALUE,
+  /** Expandable modifier node */
+  EXPANDABLE_MODIFIER,
+  /** Expression node */
+  EXPRESSION,
+  /** Extends modifier node */
+  EXTENDS_MODIFIER,
+  /** Identifier node */
+  IDENTIFIER,
+  /** Length attribute node */
+  LENGTH_ATTRIBUTE,
+  /** Map entry node */
+  MAP_ENTRY,
+  /** Number literal node */
+  NUMBER_LITERAL,
+  /** Parameter node */
+  PARAMETER,
+  /** Parameter list node */
+  PARAMETER_LIST,
+  /** Parameter value list node */
+  PARAMETER_VALUE_LIST,
+  /** Specification node */
+  SPECIFICATION,
+  /** Statement node */
+  STATEMENT,
+  /** String literal node */
+  STRING_LITERAL,
+  /** Syntax token node */
+  TOKEN,
+}

package/src/ast/node/enum/number-literal-kind.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum representing different kinds of number literals.
+ */
+export enum NumberLiteralKind {
+  /** Binary number literal */
+  BINARY,
+  /** Hexadecimal number literal */
+  HEXADECIMAL,
+  /** Integer number literal */
+  INTEGER,
+  /** Decimal number literal */
+  DECIMAL,
+  /** Multiple character number literal */
+  MULTIPLE_CHARACTER,
+  /** Floating point number literal */
+  FLOATING_POINT,
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Enum representing different kinds of statements.
+ */
+export enum StatementKind {
+  /** Array definition statement */
+  ARRAY_DEFINITION,
+  /** Computed array definition statement */
+  COMPUTED_ARRAY_DEFINITION,
+  /** Computed elementary type definition statement */
+  COMPUTED_ELEMENTARY_TYPE_DEFINITION,
+  /** Class declaration statement */
+  CLASS_DECLARATION,
+  /** Class definition statement */
+  CLASS_DEFINITION,
+  /** Compound statement */
+  COMPOUND,
+  /** Do statement */
+  DO,
+  /** Elementary type definition statement */
+  ELEMENTARY_TYPE_DEFINITION,
+  /** Expression statement */
+  EXPRESSION,
+  /** For statement */
+  FOR,
+  /** If statement */
+  IF,
+  /** Map declaration statement */
+  MAP_DECLARATION,
+  /** Map definition statement */
+  MAP_DEFINITION,
+  /** String definition statement */
+  STRING_DEFINITION,
+  /** Switch statement */
+  SWITCH,
+  /** While statement */
+  WHILE,
+}

package/src/ast/node/enum/string-literal-kind.ts

@@ -0,0 +1,13 @@
+/**
+ * Enum representing the kinds of string literals.
+ */
+export enum StringLiteralKind {
+  /**
+   * Represents a basic string literal.
+   */
+  BASIC,
+  /**
+   * Represents a UTF string literal.
+   */
+  UTF,
+}

package/src/ast/node/enum/string-variable-kind.ts

@@ -0,0 +1,25 @@
+/**
+ * Enum representing the kinds of string variables.
+ */
+export enum StringVariableKind {
+  /**
+   * Represents a UTF-8 string variable.
+   */
+  UTF8,
+  /**
+   * Represents a UTF-16 string variable.
+   */
+  UTF16,
+  /**
+   * Represents a UTF string variable.
+   */
+  UTF,
+  /**
+   * Represents a list of UTF-8 string variables.
+   */
+  UTF8_LIST,
+  /**
+   * Represents a Base64 encoded string variable.
+   */
+  BASE64,
+}

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

@@ -0,0 +1,87 @@
+/**
+ * This enum is used to categorize different types of tokens.
+ */
+export enum TokenKind {
+  ERROR_UNKNOWN_TOKEN = -2,
+  ERROR_MISSING_TOKEN = -1,
+  ABSTRACT,
+  ADDITION,
+  ALIGNED,
+  ALIGNMENT_BIT_COUNT_8,
+  ALIGNMENT_BIT_COUNT_16,
+  ALIGNMENT_BIT_COUNT_32,
+  ALIGNMENT_BIT_COUNT_64,
+  ALIGNMENT_BIT_COUNT_128,
+  ASSIGNMENT,
+  BASE64_STRING,
+  BASE64_STRING_LITERAL_CHARACTERS,
+  BINARY_LITERAL,
+  BIT,
+  BITWISE_AND,
+  BITWISE_OR,
+  BITWISE_SHIFT_LEFT,
+  BITWISE_SHIFT_RIGHT,
+  BREAK,
+  CASE,
+  CLASS,
+  CLOSE_BRACE,
+  CLOSE_BRACKET,
+  CLOSE_PARENTHESIS,
+  COLON,
+  COMMA,
+  COMPUTED,
+  CONST,
+  DECIMAL_LITERAL,
+  DEFAULT,
+  DIVISION,
+  DO,
+  DOUBLE_QUOTE,
+  ELSE,
+  EXPANDABLE,
+  EXTENDS,
+  FLOAT,
+  FLOATING_POINT_LITERAL,
+  FOR,
+  HEXADECIMAL_LITERAL,
+  IDENTIFIER,
+  IF,
+  INT,
+  INTEGER_LITERAL,
+  LEGACY,
+  LENGTHOF,
+  LOGICAL_AND,
+  LOGICAL_OR,
+  LOOK_AHEAD,
+  MAP,
+  MODULUS,
+  MULTIPLE_CHARACTER_LITERAL_CHARACTERS,
+  MULTIPLICATION,
+  OPEN_BRACE,
+  OPEN_BRACKET,
+  OPEN_PARENTHESIS,
+  PERIOD,
+  POSTFIX_DECREMENT,
+  POSTFIX_INCREMENT,
+  RANGE_OPERATOR,
+  RELATIONAL_EQUAL,
+  RELATIONAL_GREATER_THAN,
+  RELATIONAL_GREATER_THAN_OR_EQUAL,
+  RELATIONAL_LESS_THAN,
+  RELATIONAL_LESS_THAN_OR_EQUAL,
+  RELATIONAL_NOT_EQUAL,
+  RESERVED,
+  SEMICOLON,
+  SINGLE_QUOTE,
+  SUBTRACTION,
+  SWITCH,
+  UNARY_NEGATION,
+  UNARY_PLUS,
+  UNSIGNED,
+  UTF_PREFIX,
+  UTF_STRING,
+  UTF_STRING_LITERAL_CHARACTERS,
+  UTF8_LIST,
+  UTF8_STRING,
+  UTF16_STRING,
+  WHILE,
+}

package/src/ast/node/expandable-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 { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ExpandableModifier extends AbstractCompositeNode {
+  constructor(
+    public readonly expandableKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: OptionalNode<Token>,
+    public readonly maxClassSize: OptionalNode<NumberLiteral>,
+    public readonly closeParenthesisPunctuator: OptionalNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.EXPANDABLE_MODIFIER,
+      children,
+    );
+  }
+}

package/src/ast/node/explicit-array-dimension.ts

@@ -0,0 +1,26 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractArrayDimension } from "./abstract-array-dimension.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ExplicitArrayDimension extends AbstractArrayDimension {
+  constructor(
+    openBracketPunctuator: RequiredNode<Token>,
+    public readonly size: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    closeBracketPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ArrayDimensionKind.EXPLICIT,
+      openBracketPunctuator,
+      closeBracketPunctuator,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,23 @@
+import { AbstractStatement } from "./abstract-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { Identifier } from "./identifier.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { Token } from "./token.ts";
+import type { RequiredNode } from "../util/types.ts";
+
+export class ExpressionStatement extends AbstractStatement {
+  constructor(
+    public readonly expression: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.EXPRESSION,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,20 @@
+import { AbstractClassId } from "./abstract-class-id.ts";
+import type { ClassId } from "./class-id.ts";
+import type { ClassIdRange } from "./class-id-range.ts";
+import { ClassIdKind } from "./enum/class-id-kind.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { Token } from "./token.ts";
+import type { OneToManyList, ZeroToManyList } from "../util/types.ts";
+
+export class ExtendedClassIdRange extends AbstractClassId {
+  constructor(
+    public readonly classIds: OneToManyList<ClassId | ClassIdRange>,
+    public readonly commaPunctuators: ZeroToManyList<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ClassIdKind.EXTENDED_RANGE,
+      children,
+    );
+  }
+}

package/src/ast/node/extends-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 { Identifier } from "./identifier.ts";
+import type { ParameterValueList } from "./parameter-value-list.ts";
+import type { Token } from "./token.ts";
+
+export class ExtendsModifier extends AbstractCompositeNode {
+  constructor(
+    public readonly extendsKeyword: RequiredNode<Token>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly parameterValueList: OptionalNode<ParameterValueList>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.EXTENDS_MODIFIER,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,29 @@
+import type { OptionalNode, 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 { ComputedElementaryTypeDefinition } from "./computed-elementary-type-definition.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Token } from "./token.ts";
+
+export class ForStatement extends AbstractStatement {
+  constructor(
+    public readonly forKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    // either ((assignment_expression semicolon) | computed_elementary_type_definition | semicolon)
+    public readonly expression1: OptionalNode<AbstractExpression>,
+    public readonly computedElementaryDefinition: OptionalNode<
+      ComputedElementaryTypeDefinition
+    >,
+    // optional as the first semicolon can be considered part of the optional computedElementaryDefinition
+    public readonly semicolon1Punctuator: OptionalNode<Token>,
+    public readonly expression2: OptionalNode<AbstractExpression>,
+    public readonly semicolon2Punctuator: RequiredNode<Token>,
+    public readonly expression3: OptionalNode<AbstractExpression>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly statement: RequiredNode<AbstractStatement>,
+    children: Array<AbstractNode>,
+  ) {
+    super(StatementKind.FOR, children);
+  }
+}

package/src/ast/node/identifier.ts

@@ -0,0 +1,12 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+export class Identifier extends AbstractCompositeNode {
+  constructor(
+    public readonly name: string,
+    token: Token,
+  ) {
+    super(NodeKind.IDENTIFIER, [token]);
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { OptionalNode, 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 { 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 IfStatement extends AbstractStatement {
+  constructor(
+    public readonly ifKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly condition: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly ifStatement: RequiredNode<AbstractStatement>,
+    public readonly elseKeyword: OptionalNode<Token>,
+    public readonly elseStatement: OptionalNode<AbstractStatement>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.IF,
+      children,
+    );
+  }
+}

package/src/ast/node/implicit-array-dimension.ts

@@ -0,0 +1,34 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractArrayDimension } from "./abstract-array-dimension.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ImplicitArrayDimension extends AbstractArrayDimension {
+  constructor(
+    openBracketPunctuator: RequiredNode<Token>,
+    public readonly rangeStart: OptionalNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    public readonly rangeOperator: OptionalNode<Token>,
+    public readonly rangeEnd: OptionalNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    closeBracketPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ArrayDimensionKind.IMPLICIT,
+      openBracketPunctuator,
+      closeBracketPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/length-attribute.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 LengthAttribute extends AbstractCompositeNode {
+  constructor(
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly length: RequiredNode<
+      NumberLiteral | Identifier | AbstractExpression
+    >,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.LENGTH_ATTRIBUTE,
+      children,
+    );
+  }
+}

package/src/ast/node/length-of-expression.ts

@@ -0,0 +1,21 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ExpressionKind } from "./enum/expression-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { Token } from "./token.ts";
+
+export class LengthofExpression extends AbstractExpression {
+  constructor(
+    public readonly lengthOfKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly operand: RequiredNode<AbstractExpression | Identifier>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ExpressionKind.LENGTHOF,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import type {
+  OneToManyList,
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { MapEntry } from "./map-entry.ts";
+import type { Token } from "./token.ts";
+
+export class MapDeclaration extends AbstractStatement {
+  constructor(
+    public readonly mapKeyword: RequiredNode<Token>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly outputElementaryType: OptionalNode<ElementaryType>,
+    public readonly outputClassIdentifier: OptionalNode<Identifier>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly openBracePunctuator: RequiredNode<Token>,
+    public readonly mapEntries: OneToManyList<MapEntry>,
+    public readonly commaPunctuators: ZeroToManyList<Token>,
+    public readonly closeBracePunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.MAP_DECLARATION,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,27 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { Token } from "./token.ts";
+
+export class MapDefinition extends AbstractStatement {
+  constructor(
+    public readonly reservedKeyword: OptionalNode<Token>,
+    public readonly legacyKeyword: OptionalNode<Token>,
+    public readonly elementaryType: OptionalNode<ElementaryType>,
+    public readonly classIdentifier: OptionalNode<Identifier>,
+    public readonly relationalLessThanPunctuator: RequiredNode<Token>,
+    public readonly mapIdentifier: RequiredNode<Identifier>,
+    public readonly relationalGreaterThanPunctuator: RequiredNode<Token>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.MAP_DEFINITION,
+      children,
+    );
+  }
+}

package/src/ast/node/map-entry.ts

@@ -0,0 +1,18 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AggregateOutputValue } from "./aggregate-output-value.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class MapEntry extends AbstractCompositeNode {
+  constructor(
+    public readonly inputValue: RequiredNode<NumberLiteral>,
+    public readonly commaPunctuator: RequiredNode<Token>,
+    public readonly outputValue: RequiredNode<AggregateOutputValue>,
+    children: Array<AbstractNode>,
+  ) {
+    super(NodeKind.MAP_ENTRY, children);
+  }
+}

package/src/ast/node/missing-error.ts

@@ -0,0 +1,9 @@
+import { TokenKind } from "./enum/token-kind.ts";
+import { Token } from "./token.ts";
+import type { Location } from "../../location.ts";
+
+export class MissingError extends Token {
+  constructor(location: Location) {
+    super(TokenKind.ERROR_MISSING_TOKEN, "", location);
+  }
+}

package/src/ast/node/number-literal.ts

@@ -0,0 +1,18 @@
+import type { OneToManyList } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { NumberLiteralKind } from "./enum/number-literal-kind.ts";
+import type { Token } from "./token.ts";
+
+export class NumberLiteral extends AbstractCompositeNode {
+  constructor(
+    public readonly numberLiteralKind: NumberLiteralKind,
+    public readonly value: number,
+    // defined as an array to support multiple concatenated multiple character literal tokens
+    public readonly literals: OneToManyList<Token>,
+  ) {
+    super(NodeKind.NUMBER_LITERAL, literals);
+    this.numberLiteralKind = numberLiteralKind;
+    this.value = value;
+  }
+}

package/src/ast/node/parameter-list.ts

@@ -0,0 +1,25 @@
+import type {
+  OneToManyList,
+  RequiredNode,
+  ZeroToManyList,
+} 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 { Parameter } from "./parameter.ts";
+import type { Token } from "./token.ts";
+
+export class ParameterList extends AbstractCompositeNode {
+  constructor(
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly parameters: OneToManyList<Parameter>,
+    public readonly commaPunctuators: ZeroToManyList<Token>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.PARAMETER_LIST,
+      children,
+    );
+  }
+}