@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

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

@@ -9,17 +9,11 @@ import type { ExpandableModifier } from "../../node/expandable-modifier.ts";
 import type { AlignedModifier } from "../../node/aligned-modifier.ts";
 import type { BuildContext } from "../util/build-context.ts";
 import type { Token } from "../../node/token.ts";
-import {
-  fetchOptionalNode,
-  fetchRequiredNode,
-  fetchZeroToManyList,
-} from "../util/fetch-node.ts";
+import { fetchOptionalNode, fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 
-export function buildClassDeclaration(
-  buildContext: BuildContext,
-): ClassDeclaration {
+export function buildClassDeclaration(buildContext: BuildContext): ClassDeclaration {
   const children: Array<AbstractNode> = [];
   const alignedModifier = fetchOptionalNode<AlignedModifier>(
     buildContext,
@@ -46,25 +40,15 @@ export function buildClassDeclaration(
   if (abstractKeyword) {
     children.push(abstractKeyword);
   }
-  const classKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.CLASS,
-  );
+  const classKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.CLASS);
 
   children.push(classKeyword);
 
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
 
   children.push(identifier);
 
-  const parameterList = fetchOptionalNode<ParameterList>(
-    buildContext,
-    NodeKind.PARAMETER_LIST,
-  );
+  const parameterList = fetchOptionalNode<ParameterList>(buildContext, NodeKind.PARAMETER_LIST);
 
   if (parameterList) {
     children.push(parameterList);
@@ -77,10 +61,7 @@ export function buildClassDeclaration(
   if (extendsModifier) {
     children.push(extendsModifier);
   }
-  const bitModifier = fetchOptionalNode<BitModifier>(
-    buildContext,
-    NodeKind.BIT_MODIFIER,
-  );
+  const bitModifier = fetchOptionalNode<BitModifier>(buildContext, NodeKind.BIT_MODIFIER);
 
   if (bitModifier) {
     children.push(bitModifier);
@@ -93,10 +74,7 @@ export function buildClassDeclaration(
 
   children.push(openBracePunctuator);
 
-  const statements = fetchZeroToManyList<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statements = fetchZeroToManyList<AbstractStatement>(buildContext, NodeKind.STATEMENT);
 
   children.push(...statements);
 

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

@@ -7,29 +7,17 @@ import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildClassDefinition(
-  buildContext: BuildContext,
-): ClassDefinition {
+export function buildClassDefinition(buildContext: BuildContext): ClassDefinition {
   const children: Array<AbstractNode> = [];
 
-  const legacyKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.LEGACY,
-  );
+  const legacyKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.LEGACY);
   if (legacyKeyword) {
     children.push(legacyKeyword);
   }
 
-  const classIdentifier = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const classIdentifier = fetchRequiredNode<Token>(buildContext, NodeKind.IDENTIFIER);
   children.push(classIdentifier);
-  const identifier = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Token>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
   const parameterValueList = fetchOptionalNode<ParameterValueList>(
     buildContext,

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

@@ -6,27 +6,18 @@ import type { Token } from "../../node/token.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildClassIdRange(
-  buildContext: BuildContext,
-): ClassIdRange {
-  const startClassId = fetchRequiredNode<ClassId>(
-    buildContext,
-    NodeKind.CLASS_ID,
-  );
+export function buildClassIdRange(buildContext: BuildContext): ClassIdRange {
+  const startClassId = fetchRequiredNode<ClassId>(buildContext, NodeKind.CLASS_ID);
   const rangeOperator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.RANGE_OPERATOR,
   );
-  const endClassId = fetchRequiredNode<ClassId>(
-    buildContext,
-    NodeKind.CLASS_ID,
-  );
+  const endClassId = fetchRequiredNode<ClassId>(buildContext, NodeKind.CLASS_ID);
 
-  return new ClassIdRange(
+  return new ClassIdRange(startClassId, rangeOperator, endClassId, [
     startClassId,
     rangeOperator,
     endClassId,
-    [startClassId, rangeOperator, endClassId],
-  );
+  ]);
 }

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

@@ -4,16 +4,8 @@ import { ClassId } from "../../node/class-id.ts";
 import type { BuildContext } from "../util/build-context.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 
-export function buildClassId(
-  buildContext: BuildContext,
-): ClassId {
-  const value = fetchRequiredNode<NumberLiteral>(
-    buildContext,
-    NodeKind.NUMBER_LITERAL,
-  );
+export function buildClassId(buildContext: BuildContext): ClassId {
+  const value = fetchRequiredNode<NumberLiteral>(buildContext, NodeKind.NUMBER_LITERAL);
 
-  return new ClassId(
-    value,
-    [value],
-  );
+  return new ClassId(value, [value]);
 }

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

@@ -6,22 +6,16 @@ import type { Token } from "../../node/token.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildClassMemberAccess(
-  buildContext: BuildContext,
-): ClassMemberAccess {
+export function buildClassMemberAccess(buildContext: BuildContext): ClassMemberAccess {
   const classMemberAccessOperator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.PERIOD,
   );
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
 
-  return new ClassMemberAccess(
+  return new ClassMemberAccess(classMemberAccessOperator, identifier, [
     classMemberAccessOperator,
     identifier,
-    [classMemberAccessOperator, identifier],
-  );
+  ]);
 }

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

@@ -6,28 +6,22 @@ import { fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildCompoundStatement(
-  buildContext: BuildContext,
-): CompoundStatement {
+export function buildCompoundStatement(buildContext: BuildContext): CompoundStatement {
   const openBracePunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.OPEN_BRACE,
   );
-  const statements = fetchZeroToManyList<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statements = fetchZeroToManyList<AbstractStatement>(buildContext, NodeKind.STATEMENT);
   const closeBracePunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.CLOSE_BRACE,
   );
 
-  return new CompoundStatement(
+  return new CompoundStatement(openBracePunctuator, statements, closeBracePunctuator, [
     openBracePunctuator,
-    statements,
+    ...statements,
     closeBracePunctuator,
-    [openBracePunctuator, ...statements, closeBracePunctuator],
-  );
+  ]);
 }

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

@@ -9,22 +9,14 @@ import { fetchOneToManyList, fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.ts";
 
-export function buildComputedArrayDefinition(
-  buildContext: BuildContext,
-): ComputedArrayDefinition {
+export function buildComputedArrayDefinition(buildContext: BuildContext): ComputedArrayDefinition {
   const computedKeyword = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.COMPUTED,
   );
-  const elementaryType = fetchRequiredNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const elementaryType = fetchRequiredNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   const dimensions = fetchOneToManyList<ExplicitArrayDimension>(
     buildContext,
     NodeKind.ARRAY_DIMENSION,
@@ -42,12 +34,6 @@ export function buildComputedArrayDefinition(
     identifier,
     dimensions,
     semicolonPunctuator,
-    [
-      computedKeyword,
-      elementaryType,
-      identifier,
-      ...dimensions,
-      semicolonPunctuator,
-    ],
+    [computedKeyword, elementaryType, identifier, ...dimensions, semicolonPunctuator],
   );
 }

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

@@ -25,27 +25,17 @@ export function buildComputedElementaryTypeDefinition(
 
   children.push(computedKeyword);
 
-  const constKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.CONST,
-  );
+  const constKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.CONST);
 
   if (constKeyword !== undefined) {
     children.push(constKeyword);
   }
 
-  const elementaryType = fetchRequiredNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
+  const elementaryType = fetchRequiredNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
 
   children.push(elementaryType);
 
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
 
   const assignmentOperator = fetchOptionalNode<Token>(
@@ -54,22 +44,16 @@ export function buildComputedElementaryTypeDefinition(
     TokenKind.ASSIGNMENT,
   );
 
-  let value: OptionalNode<AbstractExpression | Identifier | NumberLiteral> =
-    undefined;
+  let value: OptionalNode<AbstractExpression | Identifier | NumberLiteral> = undefined;
 
   if (assignmentOperator !== undefined) {
     children.push(assignmentOperator);
 
-    value = fetchOptionalNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >(
-      buildContext,
-      [
-        NodeKind.EXPRESSION,
-        NodeKind.IDENTIFIER,
-        NodeKind.NUMBER_LITERAL,
-      ],
-    );
+    value = fetchOptionalNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+      NodeKind.EXPRESSION,
+      NodeKind.IDENTIFIER,
+      NodeKind.NUMBER_LITERAL,
+    ]);
     if (value !== undefined) {
       children.push(value);
     } else {

package/src/ast/build/node/build-decimal-literal.ts

@@ -2,14 +2,8 @@ import { NumberLiteral } from "../../node/number-literal.ts";
 import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildDecimalLiteral(
-  token: Token,
-): NumberLiteral {
+export function buildDecimalLiteral(token: Token): NumberLiteral {
   const value = parseFloat(token.text);
 
-  return new NumberLiteral(
-    NumberLiteralKind.DECIMAL,
-    value,
-    [token],
-  );
+  return new NumberLiteral(NumberLiteralKind.DECIMAL, value, [token]);
 }

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

@@ -5,31 +5,17 @@ import { DefaultClause } from "../../node/default-clause.ts";
 import type { BuildContext } from "../util/build-context.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 import type { Token } from "../../node/token.ts";
-import {
-  fetchOptionalNode,
-  fetchRequiredNode,
-  fetchZeroToManyList,
-} from "../util/fetch-node.ts";
+import { fetchOptionalNode, fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
 import type { OptionalNode } from "../../util/types.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildDefaultClause(
-  buildContext: BuildContext,
-): DefaultClause {
+export function buildDefaultClause(buildContext: BuildContext): DefaultClause {
   const children: Array<AbstractNode> = [];
 
-  const defaultKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.DEFAULT,
-  );
+  const defaultKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.DEFAULT);
   children.push(defaultKeyword);
 
-  const colonPunctuator = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.COLON,
-  );
+  const colonPunctuator = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.COLON);
   children.push(colonPunctuator);
 
   const openBracePunctuator = fetchOptionalNode<Token>(
@@ -41,10 +27,7 @@ export function buildDefaultClause(
     children.push(openBracePunctuator);
   }
 
-  const statements = fetchZeroToManyList<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statements = fetchZeroToManyList<AbstractStatement>(buildContext, NodeKind.STATEMENT);
 
   children.push(...statements);
 

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

@@ -10,32 +10,20 @@ import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import { StatementKind } from "../../node/enum/statement-kind.ts";
 
-export function buildDoStatement(
-  buildContext: BuildContext,
-): DoStatement {
-  const doKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.DO,
-  );
+export function buildDoStatement(buildContext: BuildContext): DoStatement {
+  const doKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.DO);
   const compoundStatement = fetchRequiredNode<CompoundStatement>(
     buildContext,
     NodeKind.STATEMENT,
     StatementKind.COMPOUND,
   );
-  const whileKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.WHILE,
-  );
+  const whileKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.WHILE);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.OPEN_PARENTHESIS,
   );
-  const condition = fetchRequiredNode<
-    AbstractExpression | NumberLiteral | Identifier
-  >(
+  const condition = fetchRequiredNode<AbstractExpression | NumberLiteral | Identifier>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );

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

@@ -29,20 +29,12 @@ export function buildElementaryTypeDefinition(
     children.push(reservedKeyword);
   }
 
-  const legacyKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.LEGACY,
-  );
+  const legacyKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.LEGACY);
   if (legacyKeyword !== undefined) {
     children.push(legacyKeyword);
   }
 
-  const constKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.CONST,
-  );
+  const constKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.CONST);
   if (constKeyword !== undefined) {
     children.push(constKeyword);
   }
@@ -55,10 +47,7 @@ export function buildElementaryTypeDefinition(
     children.push(alignedModifier);
   }
 
-  const elementaryType = fetchRequiredNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
+  const elementaryType = fetchRequiredNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
   children.push(elementaryType);
 
   const lengthAttribute = fetchRequiredNode<LengthAttribute>(
@@ -77,10 +66,7 @@ export function buildElementaryTypeDefinition(
     children.push(lookAheadOperator);
   }
 
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
 
   children.push(identifier);
 
@@ -90,19 +76,18 @@ export function buildElementaryTypeDefinition(
     TokenKind.ASSIGNMENT,
   );
 
-  let value: OptionalNode<AbstractExpression | Identifier | NumberLiteral> =
-    undefined;
+  let value: OptionalNode<AbstractExpression | Identifier | NumberLiteral> = undefined;
   let rangeOperator: OptionalNode<Token> = undefined;
-  let endValue: OptionalNode<AbstractExpression | Identifier | NumberLiteral> =
-    undefined;
+  let endValue: OptionalNode<AbstractExpression | Identifier | NumberLiteral> = undefined;
 
   if (assignmentOperator !== undefined) {
     children.push(assignmentOperator);
 
-    value = fetchOptionalNode<AbstractExpression | Identifier | NumberLiteral>(
-      buildContext,
-      [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-    );
+    value = fetchOptionalNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+      NodeKind.EXPRESSION,
+      NodeKind.IDENTIFIER,
+      NodeKind.NUMBER_LITERAL,
+    ]);
     if (value !== undefined) {
       children.push(value);
     } else {
@@ -119,12 +104,11 @@ export function buildElementaryTypeDefinition(
     if (rangeOperator !== undefined) {
       children.push(rangeOperator);
 
-      endValue = fetchOptionalNode<
-        AbstractExpression | Identifier | NumberLiteral
-      >(
-        buildContext,
-        [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-      );
+      endValue = fetchOptionalNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+        NodeKind.EXPRESSION,
+        NodeKind.IDENTIFIER,
+        NodeKind.NUMBER_LITERAL,
+      ]);
 
       if (endValue !== undefined) {
         children.push(endValue);

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

@@ -8,18 +8,14 @@ import { fetchRequiredNode } from "../util/fetch-node.ts";
 export function buildElementaryTypeOutputValue(
   buildContext: BuildContext,
 ): ElementaryTypeOutputValue {
-  const elementaryType = fetchRequiredNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
+  const elementaryType = fetchRequiredNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
   const lengthAttribute = fetchRequiredNode<LengthAttribute>(
     buildContext,
     NodeKind.LENGTH_ATTRIBUTE,
   );
 
-  return new ElementaryTypeOutputValue(
+  return new ElementaryTypeOutputValue(elementaryType, lengthAttribute, [
     elementaryType,
     lengthAttribute,
-    [elementaryType, lengthAttribute],
-  );
+  ]);
 }

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

@@ -6,9 +6,7 @@ import { Token } from "../../node/token.ts";
 import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import type { BuildContext } from "../util/build-context.ts";
 
-export function buildElementaryType(
-  buildContext: BuildContext,
-): ElementaryType {
+export function buildElementaryType(buildContext: BuildContext): ElementaryType {
   const children: Array<AbstractNode> = [];
   const unsignedQualifierKeyword = fetchOptionalNode<Token>(
     buildContext,
@@ -20,17 +18,13 @@ export function buildElementaryType(
     children.push(unsignedQualifierKeyword);
   }
 
-  const typeKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [TokenKind.INT, TokenKind.BIT, TokenKind.FLOAT],
-  );
+  const typeKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.INT,
+    TokenKind.BIT,
+    TokenKind.FLOAT,
+  ]);
 
   children.push(typeKeyword);
 
-  return new ElementaryType(
-    unsignedQualifierKeyword,
-    typeKeyword,
-    children,
-  );
+  return new ElementaryType(unsignedQualifierKeyword, typeKeyword, children);
 }

package/src/ast/build/node/build-expandable-modifier.ts

@@ -9,9 +9,7 @@ import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import type { OptionalNode } from "../../util/types.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildExpandableModifier(
-  buildContext: BuildContext,
-): ExpandableModifier {
+export function buildExpandableModifier(buildContext: BuildContext): ExpandableModifier {
   const children: Array<AbstractNode> = [];
 
   const expandableKeyword = fetchRequiredNode<Token>(
@@ -31,10 +29,7 @@ export function buildExpandableModifier(
 
   if (openParenthesisPunctuator) {
     children.push(openParenthesisPunctuator);
-    maxClassSize = fetchOptionalNode<NumberLiteral>(
-      buildContext,
-      NodeKind.NUMBER_LITERAL,
-    );
+    maxClassSize = fetchOptionalNode<NumberLiteral>(buildContext, NodeKind.NUMBER_LITERAL);
     if (maxClassSize) {
       children.push(maxClassSize);
     } else {

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

@@ -8,30 +8,26 @@ import { TokenKind } from "../../node/enum/token-kind.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildExplicitArrayDimension(
-  buildContext: BuildContext,
-): ExplicitArrayDimension {
+export function buildExplicitArrayDimension(buildContext: BuildContext): ExplicitArrayDimension {
   const openBracketPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.OPEN_BRACKET,
   );
-  const size = fetchRequiredNode<
-    AbstractExpression | Identifier | NumberLiteral
-  >(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const size = fetchRequiredNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
   const closeBracketPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.CLOSE_BRACKET,
   );
 
-  return new ExplicitArrayDimension(
+  return new ExplicitArrayDimension(openBracketPunctuator, size, closeBracketPunctuator, [
     openBracketPunctuator,
     size,
-    closeBracketPunctuator,
-    [openBracketPunctuator, size, closeBracketPunctuator!],
-  );
+    closeBracketPunctuator!,
+  ]);
 }

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

@@ -8,12 +8,8 @@ import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildExpressionStatement(
-  buildContext: BuildContext,
-): ExpressionStatement {
-  const expression = fetchRequiredNode<
-    AbstractExpression | Identifier | NumberLiteral
-  >(
+export function buildExpressionStatement(buildContext: BuildContext): ExpressionStatement {
+  const expression = fetchRequiredNode<AbstractExpression | Identifier | NumberLiteral>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );
@@ -23,9 +19,8 @@ export function buildExpressionStatement(
     TokenKind.SEMICOLON,
   );
 
-  return new ExpressionStatement(
+  return new ExpressionStatement(expression, semicolonPunctuator, [
     expression,
     semicolonPunctuator,
-    [expression, semicolonPunctuator],
-  );
+  ]);
 }