@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/util/token-kind-by-token-type-id-map.ts

@@ -0,0 +1,337 @@
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../../lezer/parser.terms.ts";
+
+export const tokenKindByTokenTypeId: Map<number, TokenKind> = new Map();
+
+/**
+ * Map parsed token type ID to AST token type enum.
+ * Exhaustive switch statement to ensure all token type IDs are handled.
+ */
+Object.values(TokenTypeId).forEach((tokenTypeId) => {
+  switch (tokenTypeId) {
+    case TokenTypeId._break:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BREAK);
+      break;
+    case TokenTypeId._case:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CASE);
+      break;
+    case TokenTypeId._class:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLASS);
+      break;
+    case TokenTypeId._const:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CONST);
+      break;
+    case TokenTypeId._default:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DEFAULT);
+      break;
+    case TokenTypeId._do:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DO);
+      break;
+    case TokenTypeId._else:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ELSE);
+      break;
+    case TokenTypeId._extends:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.EXTENDS);
+      break;
+    case TokenTypeId._for:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FOR);
+      break;
+    case TokenTypeId._if:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.IF);
+      break;
+    case TokenTypeId._switch:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SWITCH);
+      break;
+    case TokenTypeId._while:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.WHILE);
+      break;
+    case TokenTypeId.abstract:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ABSTRACT);
+      break;
+    case TokenTypeId.Addition:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ADDITION);
+      break;
+    case TokenTypeId.AlignmentBitCount8:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_8);
+      break;
+    case TokenTypeId.AlignmentBitCount16:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_16);
+      break;
+    case TokenTypeId.AlignmentBitCount32:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_32);
+      break;
+    case TokenTypeId.AlignmentBitCount64:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_64);
+      break;
+    case TokenTypeId.AlignmentBitCount128:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.ALIGNMENT_BIT_COUNT_128,
+      );
+      break;
+    case TokenTypeId.aligned:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNED);
+      break;
+    case TokenTypeId.Assignment:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ASSIGNMENT);
+      break;
+    case TokenTypeId.base64string:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BASE64_STRING);
+      break;
+    case TokenTypeId.Base64StringLiteralCharacters:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.BASE64_STRING_LITERAL_CHARACTERS,
+      );
+      break;
+    case TokenTypeId.BinaryLiteral:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BINARY_LITERAL);
+      break;
+    case TokenTypeId.bit:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BIT);
+      break;
+    case TokenTypeId.BitwiseAnd:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_AND);
+      break;
+    case TokenTypeId.BitwiseOr:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_OR);
+      break;
+    case TokenTypeId.BitwiseShiftLeft:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_SHIFT_LEFT);
+      break;
+    case TokenTypeId.BitwiseShiftRight:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_SHIFT_RIGHT);
+      break;
+    case TokenTypeId.CloseBrace:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_BRACE);
+      break;
+    case TokenTypeId.CloseBracket:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_BRACKET);
+      break;
+    case TokenTypeId.CloseParenthesis:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_PARENTHESIS);
+      break;
+    case TokenTypeId.Colon:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COLON);
+      break;
+    case TokenTypeId.Comma:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COMMA);
+      break;
+    case TokenTypeId.computed:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COMPUTED);
+      break;
+    case TokenTypeId.DecimalLiteral:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DECIMAL_LITERAL);
+      break;
+    case TokenTypeId.Division:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DIVISION);
+      break;
+    case TokenTypeId.DoubleQuote:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DOUBLE_QUOTE);
+      break;
+    case TokenTypeId.expandable:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.EXPANDABLE);
+      break;
+    case TokenTypeId.float:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FLOAT);
+      break;
+    case TokenTypeId.FloatingPointLiteral:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FLOATING_POINT_LITERAL);
+      break;
+    case TokenTypeId.HexadecimalLiteral:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.HEXADECIMAL_LITERAL);
+      break;
+    case TokenTypeId.Identifier:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.IDENTIFIER);
+      break;
+    case TokenTypeId.int:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.INT);
+      break;
+    case TokenTypeId.IntegerLiteral:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.INTEGER_LITERAL);
+      break;
+    case TokenTypeId.legacy:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LEGACY);
+      break;
+    case TokenTypeId.lengthof:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LENGTHOF);
+      break;
+    case TokenTypeId.LogicalAnd:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOGICAL_AND);
+      break;
+    case TokenTypeId.LogicalOr:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOGICAL_OR);
+      break;
+    case TokenTypeId.LookAhead:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOOK_AHEAD);
+      break;
+    case TokenTypeId.map:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MAP);
+      break;
+    case TokenTypeId.Modulus:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MODULUS);
+      break;
+    case TokenTypeId.MultipleCharacterLiteralCharacters:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS,
+      );
+      break;
+    case TokenTypeId.Multiplication:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MULTIPLICATION);
+      break;
+    case TokenTypeId.OpenBrace:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_BRACE);
+      break;
+    case TokenTypeId.OpenBracket:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_BRACKET);
+      break;
+    case TokenTypeId.OpenParenthesis:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_PARENTHESIS);
+      break;
+    case TokenTypeId.Period:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.PERIOD);
+      break;
+    case TokenTypeId.PostfixDecrement:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.POSTFIX_DECREMENT);
+      break;
+    case TokenTypeId.PostfixIncrement:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.POSTFIX_INCREMENT);
+      break;
+    case TokenTypeId.RangeOperator:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RANGE_OPERATOR);
+      break;
+    case TokenTypeId.reserved:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RESERVED);
+      break;
+    case TokenTypeId.RelationalEqual:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_EQUAL);
+      break;
+    case TokenTypeId.RelationalGreaterThan:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.RELATIONAL_GREATER_THAN,
+      );
+      break;
+    case TokenTypeId.RelationalGreaterThanOrEqual:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.RELATIONAL_GREATER_THAN_OR_EQUAL,
+      );
+      break;
+    case TokenTypeId.RelationalLessThan:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_LESS_THAN);
+      break;
+    case TokenTypeId.RelationalLessThanOrEqual:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.RELATIONAL_LESS_THAN_OR_EQUAL,
+      );
+      break;
+    case TokenTypeId.RelationalNotEqual:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_NOT_EQUAL);
+      break;
+    case TokenTypeId.Semicolon:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SEMICOLON);
+      break;
+    case TokenTypeId.SingleQuote:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SINGLE_QUOTE);
+      break;
+    case TokenTypeId.Subtraction:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SUBTRACTION);
+      break;
+    case TokenTypeId.UnaryNegation:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNARY_NEGATION);
+      break;
+    case TokenTypeId.UnaryPlus:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNARY_PLUS);
+      break;
+    case TokenTypeId.unsigned:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNSIGNED);
+      break;
+    case TokenTypeId.utf16string:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF16_STRING);
+      break;
+    case TokenTypeId.utf8list:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF8_LIST);
+      break;
+    case TokenTypeId.utf8string:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF8_STRING);
+      break;
+    case TokenTypeId.utfstring:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF_STRING);
+      break;
+    case TokenTypeId.UtfPrefix:
+      tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF_PREFIX);
+      break;
+    case TokenTypeId.UtfStringLiteralCharacters:
+      tokenKindByTokenTypeId.set(
+        tokenTypeId,
+        TokenKind.UTF_STRING_LITERAL_CHARACTERS,
+      );
+      break;
+
+    // Parser tokens that do not map to AST TokenKinds
+    case TokenTypeId.AlignedModifier:
+    case TokenTypeId.AggregateOutputValue:
+    case TokenTypeId.ArrayDefinition:
+    case TokenTypeId.AssignmentExpression:
+    case TokenTypeId.ArrayElementAccess:
+    case TokenTypeId.Base64StringLiteral:
+    case TokenTypeId.BinaryExpression:
+    case TokenTypeId.BitModifier:
+    case TokenTypeId.CaseClause:
+    case TokenTypeId.ClassDefinition:
+    case TokenTypeId.ClassDeclaration:
+    case TokenTypeId.ClassId:
+    case TokenTypeId.ClassIdRange:
+    case TokenTypeId.ClassMemberAccess:
+    case TokenTypeId.Comment:
+    case TokenTypeId.CompoundStatement:
+    case TokenTypeId.ComputedArrayDefinition:
+    case TokenTypeId.ComputedElementaryTypeDefinition:
+    case TokenTypeId.DefaultClause:
+    case TokenTypeId.DoStatement:
+    case TokenTypeId.ElementaryType:
+    case TokenTypeId.ElementaryTypeDefinition:
+    case TokenTypeId.ElementaryTypeOutputValue:
+    case TokenTypeId.ExpandableModifier:
+    case TokenTypeId.ExplicitArrayDimension:
+    case TokenTypeId.ExpressionStatement:
+    case TokenTypeId.ExtendedClassIdRange:
+    case TokenTypeId.ExtendsModifier:
+    case TokenTypeId.ForStatement:
+    case TokenTypeId.IfStatement:
+    case TokenTypeId.ImplicitArrayDimension:
+    case TokenTypeId.LengthAttribute:
+    case TokenTypeId.LengthofExpression:
+    case TokenTypeId.MapDeclaration:
+    case TokenTypeId.MapDefinition:
+    case TokenTypeId.MapEntry:
+    case TokenTypeId.MultipleCharacterLiteral:
+    case TokenTypeId.Parameter:
+    case TokenTypeId.ParameterList:
+    case TokenTypeId.ParameterValueList:
+    case TokenTypeId.PartialArrayDimension:
+    case TokenTypeId.Specification:
+    case TokenTypeId.StringDefinition:
+    case TokenTypeId.SwitchStatement:
+    case TokenTypeId.UnaryExpression:
+    case TokenTypeId.UtfStringLiteral:
+    case TokenTypeId.WhileStatement:
+    case TokenTypeId.Whitespace:
+      break;
+    default: {
+      const exhaustiveCheck: never = tokenTypeId;
+      throw new InternalScannerError(
+        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
+      );
+    }
+  }
+});
+
+// Add mapping for unknown token
+tokenKindByTokenTypeId.set(0, TokenKind.ERROR_UNKNOWN_TOKEN);

package/src/ast/build-ast.ts

@@ -0,0 +1,114 @@
+import type { Tree } from "@lezer/common";
+import { Text } from "@codemirror/state";
+import type { SdlStringInput } from "../lezer/sdl-string-input.ts";
+import type { Specification } from "./node/specification.ts";
+import { debugEnabled } from "../util/logger.ts";
+import type { NodeHandler } from "./visitor/node-handler.ts";
+import { TraversingVisitor } from "./visitor/traversing-visitor.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+import type { BuildContext } from "./build/util/build-context.ts";
+import type { RequiredNode } from "./util/types.ts";
+import { fetchRequiredNode } from "./build/util/fetch-node.ts";
+import { NodeKind } from "./node/enum/node-kind.ts";
+import { nodeKindByTokenTypeId } from "./build/util/node-kind-by-token-type-id-map.ts";
+
+/**
+ * Process the SDL parse tree and return an abstract syntax tree.
+ *
+ * @param parseTree The parse `Tree` generated from the SDL source.
+ * @param sdlStringInput The SDL source text as an `SdlStringInput`.
+ * @param lenient If true, the AST construction will be lenient and create error tokens and nodes for parse errors in the parse tree.
+ */
+export function buildAst(
+  parseTree: Tree,
+  sdlStringInput: SdlStringInput,
+  lenient = false,
+): RequiredNode<Specification> {
+  const text = Text.of(
+    sdlStringInput.read(0, sdlStringInput.length).split("\n"),
+  );
+  const cursor = parseTree.cursor();
+  const buildContext: BuildContext = {
+    cursor,
+    text,
+    lenient,
+    stateStack: [{ indent: "", isEndOfSiblings: false }],
+  };
+
+  const nodeKind = nodeKindByTokenTypeId.get(cursor.type.id);
+
+  if (nodeKind === undefined) {
+    throw new InternalScannerError(
+      `No nodeKind mapping found for token type id: ${cursor.type.id} (${cursor.type.name})`,
+    );
+  }
+
+  // check the root node is a Specification
+  if (nodeKind !== NodeKind.SPECIFICATION) {
+    throw new InternalScannerError(
+      `Expected start node to be a Specification, but found ${
+        NodeKind[nodeKind]
+      }.`,
+    );
+  }
+
+  const specification = fetchRequiredNode<Specification>(
+    buildContext,
+    NodeKind.SPECIFICATION,
+  );
+
+  if (buildContext.stateStack.length !== 1) {
+    throw new InternalScannerError(
+      `Expected final build context state stack length to be 1, but found ${buildContext.stateStack.length}.`,
+    );
+  }
+
+  if (!specification) {
+    throw new InternalScannerError(
+      `Expected to parse a Specification node, but none was found.`,
+    );
+  }
+
+  if ((nodeKind !== NodeKind.SPECIFICATION) && (!cursor.type.isError)) {
+    throw new InternalScannerError(
+      `Expected final node to be a Specification or an error, but found ${
+        NodeKind[nodeKind]
+      }.`,
+    );
+  }
+
+  // check if any unconsumed trivia remain which
+  if (buildContext.unconsumedTrivia) {
+    if (!specification.trailingTrivia) {
+      specification.trailingTrivia = [];
+    }
+
+    // filter from the end any empty blank line trivia
+    while (
+      (buildContext.unconsumedTrivia.length > 0) &&
+      (buildContext.unconsumedTrivia[
+        buildContext.unconsumedTrivia.length - 1
+      ].text.trim() === "")
+    ) {
+      buildContext.unconsumedTrivia.pop();
+    }
+
+    specification.trailingTrivia.push(
+      ...buildContext.unconsumedTrivia,
+    );
+
+    delete buildContext.unconsumedTrivia;
+  }
+
+  if (debugEnabled) {
+    const dummyNodeHandler: NodeHandler = {
+      beforeVisit: () => {},
+      visit: () => {},
+      afterVisit: () => {},
+    };
+    const traversingVisitor = new TraversingVisitor(dummyNodeHandler);
+    traversingVisitor.visit(specification);
+  }
+
+  return specification;
+}

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

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

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

@@ -0,0 +1,20 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+export abstract class AbstractArrayDimension extends AbstractCompositeNode {
+  constructor(
+    public readonly arrayDimensionKind: ArrayDimensionKind,
+    public readonly openBracketPunctuator: RequiredNode<Token>,
+    public readonly closeBracketPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.ARRAY_DIMENSION,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,13 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ClassIdKind } from "./enum/class-id-kind.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+
+export abstract class AbstractClassId extends AbstractCompositeNode {
+  constructor(
+    public readonly classIdKind: ClassIdKind,
+    children: Array<AbstractNode>,
+  ) {
+    super(NodeKind.CLASS_ID, children);
+  }
+}

package/src/ast/node/abstract-composite-node.ts

@@ -0,0 +1,58 @@
+import type { Location } from "../../location.ts";
+import { InternalScannerError } from "../../scanner-error.ts";
+import { isCompositeNode, isToken } from "../util/types.ts";
+import { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+
+/**
+ * Represents an abstract composite node in the abstract syntax tree.
+ * This class extends the `AbstractNode` class and provides a base for nodes
+ * that can have child nodes.
+ */
+export abstract class AbstractCompositeNode extends AbstractNode {
+  public startToken: Token | undefined;
+  public endToken: Token | undefined;
+
+  constructor(
+    nodeKind: NodeKind,
+    public readonly children: Array<AbstractNode>,
+  ) {
+    super(nodeKind, true);
+
+    if (children.length === 0) {
+      return;
+    }
+
+    const firstChild = children[0];
+    if (isCompositeNode(firstChild)) {
+      this.startToken = firstChild.startToken;
+    } else if (isToken(firstChild)) {
+      this.startToken = firstChild;
+    } else {
+      throw new InternalScannerError(
+        "Unsupported node type for start token assignment: " +
+          NodeKind[firstChild.nodeKind],
+      );
+    }
+    const lastChild = children[children.length - 1];
+    if (isCompositeNode(lastChild)) {
+      this.endToken = lastChild.endToken;
+    } else if (isToken(lastChild)) {
+      this.endToken = lastChild;
+    } else {
+      throw new InternalScannerError(
+        "Unsupported node type for end token assignment: " +
+          NodeKind[lastChild.nodeKind],
+      );
+    }
+  }
+
+  getLocation(): Location {
+    if (!this.startToken && !this.endToken) {
+      throw new InternalScannerError("Start and end token are undefined");
+    }
+
+    return this.startToken?.getLocation() ?? this.endToken!.getLocation();
+  }
+}

package/src/ast/node/abstract-elementary-type-definition.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 { ElementaryType } from "./elementary-type.ts";
+import type { 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 abstract class AbstractElementaryTypeDefinition
+  extends AbstractStatement {
+  constructor(
+    kind: StatementKind,
+    public readonly constKeyword: OptionalNode<Token>,
+    public readonly elementaryType: RequiredNode<ElementaryType>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly assignmentOperator: OptionalNode<Token>,
+    public readonly value: OptionalNode<
+      | AbstractExpression
+      | NumberLiteral
+      | Identifier
+    >,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(kind, children);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ExpressionKind } from "./enum/expression-kind.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+
+export abstract class AbstractExpression extends AbstractCompositeNode {
+  constructor(
+    public readonly expressionKind: ExpressionKind,
+    children: AbstractNode[],
+  ) {
+    super(NodeKind.EXPRESSION, children);
+  }
+}

package/src/ast/node/abstract-leaf-node.ts

@@ -0,0 +1,10 @@
+import { AbstractNode } from "./abstract-node.ts";
+import type { NodeKind } from "./enum/node-kind.ts";
+
+export abstract class AbstractLeafNode extends AbstractNode {
+  constructor(
+    nodeKind: NodeKind,
+  ) {
+    super(nodeKind, false);
+  }
+}

package/src/ast/node/abstract-node.ts

@@ -0,0 +1,16 @@
+import type { Location } from "../../location.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Trivia } from "./trivia.ts";
+
+export abstract class AbstractNode {
+  public leadingTrivia: Trivia[] | undefined;
+  public trailingTrivia: Trivia[] | undefined;
+
+  constructor(
+    public readonly nodeKind: NodeKind,
+    public readonly isComposite: boolean,
+  ) {
+  }
+
+  abstract getLocation(): Location;
+}

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

@@ -0,0 +1,13 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+
+export abstract class AbstractStatement extends AbstractCompositeNode {
+  constructor(
+    public readonly statementKind: StatementKind,
+    public readonly children: Array<AbstractNode>,
+  ) {
+    super(NodeKind.STATEMENT, children);
+  }
+}

package/src/ast/node/aggregate-output-value.ts

@@ -0,0 +1,28 @@
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { ElementaryTypeOutputValue } from "./elementary-type-output-value.ts";
+import type { Token } from "./token.ts";
+import type {
+  OneToManyList,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+
+export class AggregateOutputValue extends AbstractCompositeNode {
+  constructor(
+    public readonly openBracePunctuator: RequiredNode<Token>,
+    public readonly outputValues: OneToManyList<
+      AggregateOutputValue | ElementaryTypeOutputValue | NumberLiteral
+    >,
+    public readonly commaPunctuators: ZeroToManyList<Token>,
+    public readonly closeBracePunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.AGGREGATE_OUTPUT_VALUE,
+      children,
+    );
+  }
+}